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



Sample input:
3
7
10


Sample output:
2

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
def main():
    h = int(input())
    w = int(input())
    n = int(input())
    if h > w:
        h, w = w, h
    for y in range(h):
        n -= w
        if n <= 0:
            break
    print(y + 1)
if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math as m

H = int(input())
W = int(input())
N = int(input())
print(min(m.ceil(N / H), m.ceil(N / W)))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
from fractions import gcd
from string import ascii_lowercase as ABC
#input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
H = int(input())
W = int(input())
N = int(input())
X = max(H, W)
print(-(-N//X))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

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

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()
#print(mycnt)

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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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
        # for line in sys.stdin:
        #     lines.append(line)
        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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
args = [int(input()) for i in range(3)]
# 行と列どちら基準で塗るか　0→列，1→行
draw_flag = 0
if args[0] < args[1]:
    print(math.ceil(args[2] / args[1]))
else:
    print(math.ceil(args[2] / args[0]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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))  # type: int
    W = int(next(tokens))  # type: int
    N = int(next(tokens))  # type: int
    solve(H, W, N)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env 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))


# region fastio

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

# endregion

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#python3
import numpy as np
h = int(input())
w = int(input())
n = int(input())

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

Submission status: Accepted

Solution code:
from math import ceil

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

Submission status: Accepted

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

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

print(math.ceil(N / Max))

Submission status: Accepted

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

# 列と行の大きい方で塗れば良い
bigger=max(H,W)
print(int((N-1)/bigger)+1)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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
            # print(c,s)
            if s>=N:
                break
            W-=1
        print(c)
    else:
        c,s=0,0
        while H>0:
            s+=W
            c+=1
            # print(c,s)
            if s>=N:
                break
            H-=1
        print(c)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

M=max(H,W)

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

Submission status: Accepted

Solution code:

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#! coding utf-8

from math import ceil

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

# print(h, w, n)
# print(n//h+1, n//w+1)
ret = min(ceil(n/h), ceil(n/w))

print(ret)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8

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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

print(ans)

Submission status: Accepted

Solution code:
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])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

print(p)

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# Keyence A

import math

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#n,m = map(int,input().split())
h = int(input())
w = int(input())
n = int(input())

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

Submission status: Accepted

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

Submission status: Accepted

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