Problem:


Score: 300 points

Problem Statement

In 2028 and after a continuous growth, AtCoder Inc. finally built an empire with six cities (City 1, 2, 3, 4, 5, 6)!

There are five means of transport in this empire:

Train: travels from City 1 to 2 in one minute. A train can occupy at most A people.

Bus: travels from City 2 to 3 in one minute. A bus can occupy at most B people.

Taxi: travels from City 3 to 4 in one minute. A taxi can occupy at most C people.

Airplane: travels from City 4 to 5 in one minute. An airplane can occupy at most D people.

Ship: travels from City 5 to 6 in one minute. A ship can occupy at most E people.

For each of them, one vehicle leaves the city at each integer time (time 0, 1, 2, ...).

There is a group of N people at City 1, and they all want to go to City 6.

At least how long does it take for all of them to reach there? 
You can ignore the time needed to transfer.  

Constraints

1 \leq N, A, B, C, D, E \leq 10^{15}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A
B
C
D
E

Output

Print the minimum time required for all of the people to reach City 6, in minutes.

Sample Input 1

5
3
2
4
3
5

Sample Output 1

7

One possible way to travel is as follows.
First, there are N = 5 people at City 1, as shown in the following image:

In the first minute, three people travels from City 1 to City 2 by train. Note that a train can only occupy at most three people.

In the second minute, the remaining two people travels from City 1 to City 2 by train, and two of the three people who were already at City 2 travels to City 3 by bus. Note that a bus can only occupy at most two people.

In the third minute, two people travels from City 2 to City 3 by train, and another two people travels from City 3 to City 4 by taxi.

From then on, if they continue traveling without stopping until they reach City 6, all of them can reach there in seven minutes.

There is no way for them to reach City 6 in 6 minutes or less.

Sample Input 2

10
123
123
123
123
123

Sample Output 2

5

All kinds of vehicles can occupy N = 10 people at a time.
Thus, if they continue traveling without stopping until they reach City 6, all of them can reach there in five minutes.  

Sample Input 3

10000000007
2
3
5
7
11

Sample Output 3

5000000008

Note that the input or output may not fit into a 32-bit integer type.



Sample input:
5
3
2
4
3
5


Sample output:
7

Submission status: Accepted

Solution code:
# C
N = int(input())
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())
R = min([A, B, C, D, E])

t = N // R
if N % R != 0:
    t += 1
print(t+4)

Submission status: Accepted

Solution code:
N, a,b,c,d,e = [int(input()) for _ in range(6)]
m = min([a,b,c,d,e])

print((N//m + bool(N%m))+4)

Submission status: Accepted

Solution code:
from math import ceil
n=int(input())
A=[int(input()) for _ in range(5)]
m=min(A)
print(4+ceil(n/m))

Submission status: Accepted

Solution code:
N = int(input())
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())

r = min(A, B, C, D, E)
ans = 4 + int((N+r-1)/r)

print(ans)

Submission status: Accepted

Solution code:
N = input()
A = [input() for _ in range(5)]
print (N+min(A)-1)/min(A) + 4

Submission status: Runtime Error

Solution code:
package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"os"
	"strconv"
)

var DEBUG = true

// -----------------------------------------------------------------------------

// IO helper functions

// Returns next token from input.  It must be initialized by SetInput()
// before the first call.
var nextToken func() ([]byte, error)
var nextLine func() ([]byte, error)

// Holds a buffer for output.  It must be initialized by SetOutput().
// All IO functions (read*() and [e]print*()) should write to OutputWriter
// instead of this.
var OutputBuffer *bufio.Writer

// Holds an io.Writer.  It must be initialized by SetOutput()
var OutputWriter io.Writer

// Set IO functions for interactive input/output.
func SetInteractive(w io.Writer, r io.Reader) {
	SetUnbufferedInput(r)
	OutputBuffer = nil
	OutputWriter = w
}

// Setup OutputBuffer and OutputWriter.
func SetOutput(w io.Writer) {
	OutputBuffer = bufio.NewWriter(w)
	OutputWriter = OutputBuffer
}

// Flushes OutputBuffer
func Flush() {
	if OutputBuffer != nil {
		OutputBuffer.Flush()
	}
}

// Returns true if c is a white space
func IsSpace(c byte) bool {
	switch c {
	case '\t', '\n', '\v', '\f', '\r', ' ':
		return true
	}
	return false
}

func IsNewLine(c byte) bool {
	switch c {
	case '\n', '\r':
		return true
	}
	return false
}

// Setup nextToken with input buffer.
func SetInput(r io.Reader) {
	buf := new(bytes.Buffer)
	var b []byte

	var i int
	rest := func() ([]byte, error) {
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		return b[j:i], nil
	}
	initial := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextToken = rest
		return rest()
	}
	nextToken = initial

	restLn := func() ([]byte, error) {
		for i < len(b) && IsNewLine(b[i]) {
			i++
		}
		if i == len(b) {
			return nil, io.ErrUnexpectedEOF
		}
		j := i
		for i < len(b) && !IsNewLine(b[i]) {
			i++
		}
		return b[j:i], nil
	}

	initialLn := func() ([]byte, error) {
		io.Copy(buf, r)
		b = buf.Bytes()
		nextLine = restLn
		return restLn()
	}
	nextLine = initialLn
}

// Setup nextToken without input buffer.
func SetUnbufferedInput(r io.Reader) {
	buf := bufio.NewReader(r)
	var b []byte

	var i int
	nextToken = func() ([]byte, error) {
		var err error
		if i == len(b) {
			b, err = buf.ReadBytes('\n')
			if err != nil {
				return nil, err
			}
			i = 0
			j := len(b) - 1
			for 0 <= j && IsSpace(b[j]) {
				j--
			}
			b = b[0 : j+1]
		}
		for i < len(b) && IsSpace(b[i]) {
			i++
		}
		j := i
		for i < len(b) && !IsSpace(b[i]) {
			i++
		}
		if i == j {
			return nil, io.ErrUnexpectedEOF
		}
		return b[j:i], nil
	}
}

// -----------------------------------------------------------------------------

// IO functions

// Reads next token and return it as []byte
func readb() []byte {
	b, err := nextToken()
	if err != nil {
		panic(err)
	}
	return b[:len(b):len(b)]
}

// Reads next token and return it as string
func reads() string {
	return string(readb())
}

// Read next line as []byte.  Trailing '\n' will not be included.
// See also comments on readb()
func readbln() []byte {
	b, err := nextLine()
	if err != nil {
		panic(err)
	}
	return b[:len(b):len(b)]
}

// Read next line as string
func readsln() string {
	return string(readbln())
}

// Reads next token and return it as int64
func readll() int64 {
	i, err := strconv.ParseInt(reads(), 10, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// Reads next token and return it as int
func readi() int {
	return int(readll())
}

// Reads next token and return it as float64
func readf() float64 {
	f, err := strconv.ParseFloat(reads(), 64)
	if err != nil {
		panic(err.Error())
	}
	return f
}

// Write args to OutputWriter with the format f
func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(OutputWriter, f, args...)
}

// Write args to OutputWriter without format
func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(OutputWriter, args...)
}

// Write args to stderr with the format f
func eprintf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(os.Stderr, f, args...)
}

// Write args to stderr without format
func eprintln(args ...interface{}) (int, error) {
	return fmt.Fprintln(os.Stderr, args...)
}

func debugf(f string, args ...interface{}) {
	if !DEBUG {
		return
	}
	fmt.Fprintf(os.Stderr, f, args...)
}

func debug(args ...interface{}) {
	if !DEBUG {
		return
	}
	fmt.Fprintln(os.Stderr, args...)
}

// -----------------------------------------------------------------------------

// Utilities

func sumSlice(a []int) int {
	var res int
	for _, v := range a {
		res += v
	}
	return res
}

func sumSlicell(a []int64) int64 {
	var res int64
	for _, v := range a {
		res += v
	}
	return res
}

func readInts(N int) (int, []int) {
	if N == 0 {
		N = readi()
	}
	a := make([]int, N)
	for i := range a {
		a[i] = readi()
	}
	return N, a
}

func readIntsll(N int) (int, []int64) {
	if N == 0 {
		N = readi()
	}
	a := make([]int64, N)
	for i := range a {
		a[i] = readll()
	}
	return N, a
}

// -----------------------------------------------------------------------------

// Simple math functions

const (
	// big prime
	INF  = 1000000007
	INF2 = 1000000009
	INF3 = 998244353
)

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func minll(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func minf(a, b float64) float64 {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}

func maxll(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func maxf(a, b float64) float64 {
	if a < b {
		return b
	}
	return a
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func absll(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

func absf(a float64) float64 {
	if a < 0 {
		return -a
	}
	return a
}

// egcd(a, b) returns d, x, y:
//   d is gcd(a,b)
//   x, y are  integers that satisfy ax + by = d
func egcd(a, b int) (int, int, int) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcd(b, a%b)
	return d, y, x - a/b*y
}

func egcdll(a, b int64) (int64, int64, int64) {
	if b == 0 {
		return a, 1, 0
	}
	d, x, y := egcdll(b, a%b)
	return d, y, x - a/b*y
}

func gcd(a, b int) int {
	d, _, _ := egcd(a, b)
	return d
}

func gcdll(a, b int64) int64 {
	d, _, _ := egcdll(a, b)
	return d
}

// set up IO functions
func init() {
	// for non-interactive
	SetInput(os.Stdin)
	SetOutput(os.Stdout)

	// Enable below when interactive.  Its ok to leave above intact.
	SetInteractive(os.Stdout, os.Stdin)
}

func main() {
	defer Flush()
	n := readi()
	cities := make([]int, 5)
	for i := 0; i < 5; i++ {
		cities[i] = readi()
	}
	answer := solve(n, cities)
	println(answer)
}

func solve(n int, cities []int) int {
	longest := 100000000000000
	for i := 0; i < len(cities); i++ {
		longest = min(longest, cities[i])
	}
	miniutes := n / longest
	if longest%n != 0 {
		miniutes++
	}
	miniutes += len(cities) - 1
	return miniutes
}

Submission status: Runtime Error

Solution code:
n=int(input())
x = [int(input()) for _ in range(n)]
p = min(x)
q = n//p
print(q+5)

Submission status: Runtime Error

Solution code:
def main():
    n = int(input())
    data = [int(input()) for i in range(5)]
    quo, rem = divmod(n, min(data))
	print(4 + quo + bool(rem))

main()

Submission status: Runtime Error

Solution code:
n = int(input().split())
x = [int(input()) for i in range(5)]
d = n // min(x)
print(d+5)

Submission status: Runtime Error

Solution code:
n = int(input().split())
x = [int(intpu()) for i in range(5)]
d = n // min(x)
print(d+5)

Submission status: Runtime Error

Solution code:
N = int(input())
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())
X = min(A, B, C, D, E)
if X >= N:
  print(5)
else:
  if N%X == 0:
    print(4+N//X)
  elese:
    print(5+N//X)

Submission status: Runtime Error

Solution code:
N = int(input())
transport = [int(input()) for _ in range(5)]
print(int(N / np.min(transport) + 5))

Submission status: Runtime Error

Solution code:
k, n = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
df = [0] * (n - 1)
for i in range(n - 1):
    df[i] = abs(x[i + 1] - x[i])

df = sorted(df, reverse=True)
print(sum(df[k - 1 :]))

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[input() for i in range(5)]
print(math.ceil(n/min(l))+4)

Submission status: Runtime Error

Solution code:
N = int(input())
Cap = [int(input()) for X in range(0,5)]
print(int(math.ceil(N/min(Cap))+4))

Submission status: Runtime Error

Solution code:
N = int(input())
Cap = [int(input()) for X in range(0,5)]
Str = math.ceil(N/Cap[0])
for T in range(0,len(Cap)-1):
    Str += math.ceil(Cap[T]/Cap[T+1])
print(Str)

Submission status: Runtime Error

Solution code:
import math
n = int(input())
l=[int(input) for i in range(5)]
print(math.ceil(n/min(l))+4)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[int(input()) for i in range(5)]
print(mat.ceil(n/min(l))+4)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[int(input()) for in range(5)]
print(mat.ceil(n/min(l))+4)

Submission status: Runtime Error

Solution code:
N = int(input())
Carry = []
for i in range(5):
    Carry.append(int(input()))
min_num = min(Carry)
if N % min_num == 0:
    print((N//min(max_Carry)))
else:
    print((N//min(max_Carry))+5)

Submission status: Runtime Error

Solution code:
import math

N = int(input())
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())

t1 = math.floor(N / A)
B = (t1 -1 ) * B
N = max(N % A,N-B)

t2 = math.floor(N / B)
C = (t2 -1 ) * C
N = max(N % B,N-C)

t3 = math.floor(N / C)
D = (t3 -1 ) * D
N = max(N % C,N-D)

t4 = math.floor(N / D)
E = (t4 -1 ) * E
N = max(N % D,N-E)

t5 = math.floor(N / E)

print(int(t1+t2+t3+t4+t5))

Submission status: Runtime Error

Solution code:
import math
n=int(input())
a=[int(input()) for i in range(5)]
b=0
for i in range(5):
  b=max(math.ceil(n//a[i]))
print(5+b-1)

Submission status: Runtime Error

Solution code:

n=int(input())
l=[]
for i in range(5):
    l.append(int(input()))
#print(l)
m=min(l)
"print(m)

print(-(-n//int(m))+4)

Submission status: Runtime Error

Solution code:
n = int(input())
l = (int(input()) for i in range(5))
l2 = []
for i in range(5):
    if n % l[i] == 0:
        l2.append(n // l[i])
    else:
        l2.append(n // l[i] + 1)
l2.sort(reverse = True)
print(l2[0] + 4)

Submission status: Runtime Error

Solution code:
n = int(input())
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
num = min(a, b, c, d, e)
cnt = n // nu if n % num == 0 else n // num + 1
print(cnt + 4)

Submission status: Runtime Error

Solution code:
n = int(input())
#n, m = list(map(int, input().split()))
# a, b, c = list(map(int, input().split()))
abc = [int(input()) for i in range(5)]
count = 0
start = math.ceil(n/abc[0])-1
_min = abc[0]
for i in range(5):
    if abc[i] < _min:
        count += math.ceil((_min-abc[i])/abc[i])
        _min = abc[i]

print(count+start+5)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[int(input()) for i in range(n)]
ans=math.ceil(n/len(l))+4
print(ans)

Submission status: Runtime Error

Solution code:
import math
n = int(input())
lis = [int(input()) for i in range(n)]
print(5 + math.ceil(n/min(lis))-1)

Submission status: Runtime Error

Solution code:
n = int(input())
a = [int(input()) for i in range(n)]
print(-(-n // min(a)) + 4)

Submission status: Runtime Error

Solution code:
N = int(input())
quank = [int(input()) for _ in range(N)]
b = min(quank)
if N % b == 0:
    a = N//b
else:
    a = N//b + 1
print(a+4)

Submission status: Runtime Error

Solution code:
N = int(input())
capacity = [int(input()) for _ in range(N)]
b = min(capacity)
if N % b == 0:
    a = N//b
else:
    a = N//b + 1
print(a+4)

Submission status: Runtime Error

Solution code:
n = int(input())
a = [int(input()) for _ in range(6)]

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

Submission status: Runtime Error

Solution code:
n = int(input())
p = [int(input()) for _ in range(n)]
pmin = min(i for i in p)

import math
print(math.ceil(n/pmin)+4)

Submission status: Runtime Error

Solution code:
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list
#from itertools import combinations # (string,3) 3回
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#

mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    # 例えば、(A,B,C,D,E) = (5,3,4,2,6) だったら、D = 2の部分で絶対に人が詰まる
    # Dはボトルネック(一番処理がﾀﾞﾒ)
    # N = 100だとすると、最初にDに来てからはずっと2人ずつのせていく
    # 時間で言うと N // 2 = 50 分 かかる計算になる
    # しかし、全員ぴったりくるわけではないので、 (N + bottleneck - 1) // bottleneckにする
    # Dが一番小さいのだから、
    # Dにくるまでは、A,B,C の　3分
    # Dを過ぎてからはE の　1分
    # これは、ボトルネックがDの場合に限らない 合計で 4分
    n = int(input())
    bottleneck = int(input())
    for i in range(n-1):
        bottleneck = min(bottleneck,int(input()))
    #print(bottleneck)
    print((n + bottleneck - 1) // bottleneck + 4) # ボトネで処理するもの　と　来るまでと来た後　の合計

if __name__ == '__main__':
  main()

Submission status: Runtime Error

Solution code:
n=int(input())
t=[int(input()) for _ in range(4)]
if n//min(t)<1:
    n//min(t)=1
print(n//min(t) +4)

Submission status: Runtime Error

Solution code:
n=int(input())
t=[int(input()) for _ in range(5)]
if n//min(t)<1:
    n//min(t)=1
print(n//min(t) +4)

Submission status: Runtime Error

Solution code:
n=int(input())
t=[int(input()) for _ in range(n)]
if n//min(t)<1:
    n//min(t)=1
print(n//min(t) +4)

Submission status: Runtime Error

Solution code:

n = int(input())
l = [int(input()) for i in range(n)]

x = min(l)
print((int(n/x)+1) + 4)

Submission status: Runtime Error

Solution code:
List = []
for _ in range(6):
  List.append(int(input()))
Count = 5
MIN = min(List[1],List[2],List[3],List[4],List[5],)
Count += List[0]//MIN if List[0]%MIN != 0 else Count += (List[0]//MIN)-1

print(Count)

Submission status: Runtime Error

Solution code:
n = int(input())
l = list(int(input()) for i in range(n))
a = -(-n//min(l))+4
print(a)

Submission status: Runtime Error

Solution code:
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
a = [I() for i in range(5)]

print(math.ceil(N/min(a))+4)

Submission status: Runtime Error

Solution code:
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
a = [I() for i in range(5)]

print(math.ceil(N/min(a))+4)

Submission status: Runtime Error

Solution code:
n = int(input())
a = [int(input()) for _ in range(5)]
print(math.ceil(n/min(a))+4)

Submission status: Runtime Error

Solution code:
import math
n = int(input())
a = [int(input()) for _ in range(n)]
print(math.ceil(n/min(a))+4)

Submission status: Runtime Error

Solution code:
import math
N=int(input())
A=[int(input()) for i in range(5)]
print(math.ceil(N/min(A)+4)

Submission status: Runtime Error

Solution code:
N = int(input())
T = [int(input()) for _ in range(5)]
print(5 + ceil(N // min(T)))

Submission status: Runtime Error

Solution code:
def count_section_by_zero(data):
  count = 0
  flg = False
  start = 0
  for i, d in enumerate(data):
    if flg is False and d != 0:
      count += 1
      flg = True
      
    if d == 0:
      flg = False
  return count

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

def input_list_str():
  return list(map(str, input().split()))

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

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

def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

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

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

# 2で割り切れる回数
def divide_two(arg):
  c = 0
  while True:
    if c >= 2:
      break
    if arg % 2 != 0:
      break
    arg //= 2
    c += 1
  return c

# 素因数分解
def prime_factorize(n):
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a

def main():
  n = int(input())
  nums = []
  for i in range(n):
    nums.append(int(input()))
  
  min_num = min(nums)
  print(math.ceil(n/min_num)+4)
  
import math
import fractions
import collections
import itertools
from functools import reduce
main()

Submission status: Runtime Error

Solution code:
import math
n=int(input)
l=[int(input) for _ in range(5)]
print(math.ceil(n/min(l)+4))

Submission status: Runtime Error

Solution code:
import math
n=int(input)
l=[int(input) for _ in range(5)]
print(ceil(n/min(l)+4))

Submission status: Runtime Error

Solution code:
n = int(input())
abc = []
ans = 0

for i in range(5) :
    abc.append(int(input()))

minabc = min(abc)
ans += n//minabc

if x >= n :
    print(5)
else :
    print(5 + ans)

Submission status: Runtime Error

Solution code:
def main():
    N=int(input())
    A=int(input())
    B=int(input())
    C=int(input())
    D=int(input())
    E=int(input())
    for i in (A,B,C,D,E):
        min_num=min(i,min_num)
    print((N//min_num+1)+4)
    
if __name__=="__main__":
    main()

Submission status: Runtime Error

Solution code:
def solve():
    N = int(input())
    ABCDE = []
    for _ in range(5):
        ABCDE.append(int(input()))
        
    min_ = min(ABCDE)
    
    print(math.floor(N/min_)+4)
    
solve()

Submission status: Runtime Error

Solution code:
satoooh
import math
#入力値を定義
N, A, B, C, D, E = eval("int(input())," * 6)
# Nをmin(A~E)で割った商を繰り上げた分だけ、移動が余計にかかる
print(4 + math.ceil(N / min(A, B, C, D, E)))

Submission status: Runtime Error

Solution code:
N = int(input())
ls = [int(input()) for range(5)]
X = min(ls)
print((N+X-1)//X+4)

Submission status: Runtime Error

Solution code:
N=int(input())
A=[int(input()) for range(N)]
X=min(A)
ans=(N+X-1)//X +4
print(ans)

Submission status: Runtime Error

Solution code:
N, A, B, C, D, E = map(int, input().split())
list=[A, B, C, D, E]
min=min(list)
print(-(-N//min)

Submission status: Runtime Error

Solution code:
N, A, B, C, D, E = map(int, input().split())
min=min(A, B, C, D, E)
print(-(-N//min)

Submission status: Runtime Error

Solution code:
N, A, B, C, D, E = map(int, input().split())
min=min(A, B, C, D, E)
print(N//min+1)

Submission status: Runtime Error

Solution code:
N, A, B, C, D, E = map(int, input().split())
min=min(A, B, C, D, E)
print(-(-N//min))

Submission status: Runtime Error

Solution code:
N, A, B, C, D, E = map(int, input().separate())
min=min(A, B, C, D, E)
print(-(-N//min))

Submission status: Runtime Error

Solution code:
import math
n = int(input())
for i in range(5):
  l = int(input())
print(math.ceil(n/min(l))+4)

Submission status: Runtime Error

Solution code:
import math
n = int(input())
for i in range(n):
  l = int(input())
print(math.ceil(n/min(l))+4)

Submission status: Runtime Error

Solution code:
#--import&define---------------------
import math

def yes():
    print("Yes")
def no():
    print("No")
#--my_library--------------------------------
#mapを利用したリストの入力
# x,y = map(int,input().split())

#forを利用したリストの入力
#l = []
#for i in range():
#    l.append(int(input()))

#intの最大値と最小値
#maxX = 2147483647
#minX =-2147483648
#--以下解答---------------------------------

n = int(input())
l = []
# min = 2147483647
for i in range(5):
    l.append(int(input()))
    # min = l[i] if l[i]<min else min
minV = min(l)
print(int((n+minV-1)/min) +4)
# if n%min == 0:
#     print(n//min +4)
# else:
#     tmp = int(n//min) +1
#     print(tmp+4)

Submission status: Runtime Error

Solution code:
#--import&define---------------------
import math

def yes():
    print("Yes")
def no():
    print("No")
#--my_library--------------------------------
#mapを利用したリストの入力
# x,y = map(int,input().split())

#forを利用したリストの入力
#l = []
#for i in range():
#    l.append(int(input()))

#intの最大値と最小値
#maxX = 2147483647
#minX =-2147483648
#--以下解答---------------------------------

n = int(input())
l = []
min = 2147483647
for i in range(n):
    l.append(int(input()))
    min = l[i] if l[i]<min else min

if n%min == 0:
    print(n/min+4)
else:
    tmp = int(n/min) +1
    print(tmp+4)

Submission status: Runtime Error

Solution code:
#--import&define---------------------
import math

def yes():
    print("Yes")
def no():
    print("No")
#--my_library--------------------------------
#mapを利用したリストの入力
# x,y = map(int,input().split())

#forを利用したリストの入力
#l = []
#for i in range():
#    l.append(int(input()))

#intの最大値と最小値
#maxX = 2147483647
#minX =-2147483648
#--以下解答---------------------------------
#分からない

n = int(input())
l = []
min = 2147483647
for i in range(n):
    l.append(int(input()))
    min = l[i] if l[i]<min else min

if n%min == 0:
    print(n/min+4)
else:
    tmp = n/min +1
    print(n/tmp+4)

Submission status: Runtime Error

Solution code:
import math

n=int(input())
a=[int(input()) for i in range(n)]

print(4+math.ceil(n/min(a)))

Submission status: Runtime Error

Solution code:
import math
n=int(input())
a=[int(input()) for i in range(n)]
w=math.ceil(n/min(a))
print(w+4)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
a=[int(input()) for i in range(n)]
m=min(a)
w=math.ceil(n/m)
print(w+4)

Submission status: Runtime Error

Solution code:
n = int(input())
*args, = [int(input()) for _ in range(n)]

worst = min(args)

print(6 + n // worst)

Submission status: Runtime Error

Solution code:
n=int(input())
for i in range(5):
  x.append(int(input()))
a=max(x)
print(n//a+5)

Submission status: Runtime Error

Solution code:
n=int(lnput())
for i in range(5):
  x.append(int(input()))
a=max(x)
print(n//a+5)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[]
for i in range(n):
    l.append(int(input()))

print(math.ceil(n/min(l))-1+5)

Submission status: Runtime Error

Solution code:
N,*A=map(int,input().split())
print(max((N//min(A)+4),5))

Submission status: Runtime Error

Solution code:

N=int(input())
n=[]
n.append(int(input())
n.append(int(input())
n.append(int(input())
n.append(int(input())
n.append(int(input())

print(5+N//min(n))

Submission status: Runtime Error

Solution code:
x, y, z, k = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list((map(int,input().split())))
D = []
E = []
for i in range(x):
  for j in range(y):
    D.append(A[i]+B[j])
D.sort()
for i in range(z):
  for j in range(min(len(D),k)):
    E.append(C[i]+D[::-1][j])
print("\n".join(map(str,sorted(E)[::-1][:k])))

Submission status: Runtime Error

Solution code:
#--import&define---------------------
import math

def yes():
    print("Yes")
def no():
    print("No")
#--my_library--------------------------------
#mapを利用したリストの入力
# x,y = map(int,input().split())

#forを利用したリストの入力
#l = []
#for i in range():
#    l.append(int(input()))

#intの最大値と最小値
#maxX = 2147483647
#minX =-2147483648 
#--以下解答---------------------------------
n = int(input())
l = []
min = 2147483647
for i in range(n):
   l.append(int(input()))
   min = l[i] if l[i]<min else min

if n%min == 0:
    print(int(n/min)+4)
else:
    tmp = int(n/min) +1
    print(tmp+4)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[int(input()) for i in range(5)]
print(math.ceil(n/min(l)+4)

Submission status: Runtime Error

Solution code:
import math
n=int(input())
l=[int(input()) for i in range(6)]
print(math.ceil(n/min(l)+4)

Submission status: Runtime Error

Solution code:
n = int(input())
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())

neck = min(a,b,c,d,e)

cnt = 5 + math.ceil(n / neck) - 1

print(cnt)

Submission status: Runtime Error

Solution code:
import stdin from sys
n = int(stdin.readline().rstrip())
li = [int(stdin.readline().rstrip()) for _ in range(5)]
m = min(li)
if n % m == 0:
    print(n//m + 4)
else:
    print(n//m + 5)

Submission status: Runtime Error

Solution code:
import stdin from sys
n = int(stdin.readline().rstrip())
li = [int(stdin.readline().rstrip() for _ in range(5))]
m = min(li)
if n % m == 0:
    print(n//m + 4)
else:
    print(n//m + 5)

Submission status: Runtime Error

Solution code:
import stdin from sys
n = int(stdin.readline())
li = int(stdin.readlines())
m = min(li)
if n % m == 0:
    print(n//m + 4)
else:
    print(n//m + 5)

Submission status: Runtime Error

Solution code:
n = int(input())
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
m = min(a,b,c,d,e)
print(ceil(n/m) + 4)

Submission status: Runtime Error

Solution code:
N = int(input())
n = [int(input()) for _ in range(N)]
min_n = min(n)
print(N // min_n + (1 if (0 != N % min_n) else 0) + N - 1)

Submission status: Runtime Error

Solution code:
N = int(input())
cap = [int(input()) for i in range(5)]
state = [N, 0, 0, 0, 0, 0]
time = 0
while state[-1] != N:
    for i in range(4,-1,-1):
        if state[i]==0:
            continue
        move = cap if state[i]>=cap[i] else state[i]
        state[i] -= move
        state[i+1] += move
    time += 1
print(time)

Submission status: Runtime Error

Solution code:
p = [a, b, c, d, e]
n//min(p)+5

Submission status: Runtime Error

Solution code:
N=int(input())
rissoku=10**9

for _ in range(5):
    rissoku=min(rissoku,int(input()))

if N%rissoku=0:
    print((N//rissoku)+4)
else:
    print((N//rissoku)+5)

Submission status: Runtime Error

Solution code:
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
chi=min([a,b,c,d,e])
answer=ceil(n/chi)+4
print(int(answer))

Submission status: Runtime Error

Solution code:
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
chi=min([a,b,c,d,e])
answer=ceil(n/chi)+4
print(answer)

Submission status: Runtime Error

Solution code:
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
chi=min([a,b,c,d,e])
answer=ceil(n//chi)+4
print(answer)

Submission status: Runtime Error

Solution code:
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())

print(ceil(n/min(a,b,c,d,e)+4))

Submission status: Runtime Error

Solution code:
n=int(input())
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())

mi=min(a,b,c,d,e)
if n%mi != 0
    print((n//mi)+1+4)
else:
    print((n//mi)+4)

Submission status: Runtime Error

Solution code:
#include<bits/stdc++.h>
#include <iomanip>
#include <iostream>
using namespace std;
using ll = long long;
ll INF = 9999999999999999;

template<class T> inline bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template<class T> inline bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
ll max(ll a, ll b){
    if(a > b) return a;
    else return b;
}
 
ll min(ll a, ll b){
    if(a < b) return a;
    else return b;
}

int main(void){
    ll N; cin >> N;
    ll min_X = 100000000000000001;
    for(int i = 0; i < 5; i++){
        ll X;
        cin >> X;
        min_X = min(min_X, X);
    }
    ll ans = 4;
    ans += (N/min_X)+1;
    if(N % min_X == 0) ans++;
    cout << ans << endl;
}

Submission status: Runtime Error

Solution code:
N = int(input())
ABC = []*5
for i in range(5):
  ABC[i] = int(input())
  
Amin = min(ABC)

if N%Amin ==0:
  ans = N//2-1+5
else:
  ans = N//2+5

print(ans)

Submission status: Runtime Error

Solution code:
lis = [int(input()) for _ in range(6)]
print(lis(0)//min(lis[1:])+5)

Submission status: Runtime Error

Solution code:
N = int(input())
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())
print(math.ceil(N/min(A,B,C,D,E))+4)