草稿箱，无用且不完整，请忽略6

141

'''141，输入N，再输入N个数形成一个保证有序的列表，输入M，再输入M个数，
依次输出这每个数在列表中有没有（可利用函数）如果有输出YES，如果没有输出NO
输入
5 
1 3 5 7 9  #换行
3    
3 2 0   #换行
输出
yes
no
no
'''
def find(l,a):
    start=0
    end=len(l)-1
    mid=(start+end)//2
    if start>=(end-1):
        return 'no'
    elif l[mid]==a:
        return 'yes'
    elif l[mid]>a:
            return find(l[start:mid+1],a)
    else:
            return find(l[mid:end+1],a)
N=int(input("请输入N："))
l1=[]
l2=[]
for i in range(N):
    l1.append(int(input()))
M=int(input("请输入M："))
for j in range(M):
    l2.append(int(input()))
for z in range(M):
    print (find(l1,l2[z]))

142

'''142, 输入N，再输入N个数形成一个保证有序的列表，输入M，寻找M在列表中的位置。
有以下几种情况：
（1）如果没有M，输出NO
（2）如果有多个M，输出第一个出现的位置和最后一个出现的位置。
（3）如果仅有1个M，单独输出那个位置即可。

'''
def find(l,a):
    start=0
    end=len(l)-1
    mid=(start+end)//2
    if start>=(end-1):
        return 'no'
    elif l[mid]==a:
        return mid+1
        #return mid+1
    elif l[mid]>a:
            return find(l[start:mid+1],a)
    else:
            return find(l[mid:end+1],a)

N=int(input("请输入N："))
l1=[]
for i in range(N):
    l1.append(int(input()))
M=int(input("请输入M："))
if type(find(l1,M))==int:
    a_l=a_r=find(l1,M)
    while l1[a_l-1]==M:
        a_l-=1
    #print (a_l+1)
    a_r=find(l1,M)
    while  l1[a_r-1]==M:
        a_r+=1
    #print (a_r-1)
    if a_l+1==a_r-1:
        print (a_l+1)
    else:
        print (a_l+1,a_r-1)
        
else:
    print (find(l1,M))

143

'''143，奇怪的函数
使得 x**x达到或超过 n 位数字的最小正整数 x 是多少？
输入
一个正整数 n
输出
使得 x**x 达到 n 位数字的最小正整数 x
样例输入11
样例输出10
保证n<=2000000000

'''
import math
def check(a,n):
    return a*math.log10(a)>=n-1

n=int(input("请输入正整数n："))
l=1
r=1000000000
while l<r/10:
    mid=(1+r)//10
    if check(mid,n):
        r=mid
    else:
        l=mid
    print (r)

#print(check(3,3))

144

'''144，输入N和K，再输入N个数形成列表，不改变这些数的位置顺序，
将这些数划分为K组，这K个组就有K个和，请问如果划分，能让这K个和的最大值最小，
输出这个最小的最大和。
'''
'''N,K=map(int,input("请输入N，K：").split())
l1=[]
for i in range(N):
    l1.append(int(input()))
'''

class Solution:
    def splitArray(self, nums: list[int], m: int) -> int:
        def countGroups(mid):
            temp = 0
            count = 1
            for num in nums:
                temp += num
                if temp > mid:
                    count += 1
                    temp = num # 准备下一组
            return count
        
        left, right = max(nums), sum(nums)
        
        while left < right:
            mid = left + (right - left) // 2
            num_group = countGroups(mid)
            
            if num_group > m: # 划分多了，mid太小了
                left = mid + 1
            else:
                right = mid
        print(left, mid, right)
        return left # left恰好是满足条件的最少分割，自然就最大

144-2

'''输入N和K，再输入N个数形成列表，不改变这些数的位置顺序，将这些数划分为K组，这K个组就有K个和，
请问如果划分，能让这K个和的最大值最小，输出这个最小的最大和。
'''

def Kpart(arr,start,end,k):
    if k == 1:
        sum=0
        for i in range(start,end+1):
            sum+=arr[i]
        return sum
    elif (end-start+1)==k:
        max=2147483647
        for i in range(start,end+1):
            if arr[i]>max:
                max=arr[i]
        return max

    min=-2147483648
    for i in range(start,end+1-k+1):
        sum=0
        for j in range(start,i+1):
            sum+=arr[j]
        if sum>Kpart(arr,i+1,end,k-1):
            larger=sum
        else:
            larger=Kpart(arr,i+1,end,k-1)
        if larger<min:
            min=larger
        # -2147483648
    return min

146

'''146，伐木工人米尔科需要砍倒M米长的木材。这是一个对米尔科来说很容易的工作，
因为他有一个漂亮的新伐木机，可以像野火一样砍倒森林。不过，米尔科只被允许砍倒单行树木。
米尔科的伐木机工作过程如下：米尔科设置一个高度参数H（米），伐木机升起一个巨大的锯片到高度H，
并锯掉所有的树比H高的部分（当然，树木不高于H米的部分保持不变）。米尔科就行到树木被锯下的部分。
例如，如果一行树的高度分别为20，15，10和17，米尔科把锯片升到15米的高度，
切割后树木剩下的高度将是15，15，10和15，而米尔科将从第1棵树得到5米，从第4棵树得到2米，
共得到7米木材。米尔科非常关注生态保护，所以他不会砍掉过多的木材。
这正是他为什么尽可能高地设定伐木机锯片的原因。帮助米尔科找到伐木机锯片的最大的整数高度H，
使得他能得到木材至少为M米。换句话说，如果再升高1米，则他将得不到M米木材。
输入格式
首先2个整数N和M，N表示树木的数量,M表示需要的木材总长度
其次N个整数表示每棵树的高度，值均不超过1000000000。所有木材长度之和大于M，因此必有解。
输出格式
第1行：1个整数，表示砍树的最高高度。
输入输出样例
输入
5 20
4 42 40 26 46
输出
36
'''
def judge(x,N,tree,M):#判断树高是否满足条件
    sum = 0
    for i in range(N):
        if x<tree[i]:
            sum+=(tree[i]-x)
    if sum>=M:
        return 1
    else:
        return 0
N,M=map(int,input("请输入NM：").split())
tree=[]
for i in range(N):
    tree.append(int(input()))
max_tree=max(tree)
left=0
right=max_tree
mid=(left+right)//2
answer=0
while left<right:
    mid=(left+right)//2
    if judge(mid,N,tree,M)==1:
        answer=mid
        left=mid+1
    else:
        right=mid-1
print (answer)

147

'''147，熊大妈决定给每个牛宝宝都穿上可爱的婴儿装 。但是由于衣服很湿，为牛宝宝晒衣服就成了很不爽的事情。
于是，熊大妈请你（奶牛）帮助她完成这个重任。
一件衣服在自然条件下用一秒的时间可以晒干 a 点湿度。
抠门的熊大妈只买了一台烘衣机 。
使用用一秒烘衣机可以让一件衣服额外烘干 b 点湿度（一秒晒干 a+b 湿度），
但在同一时间内只能烘一件衣服。
现在有 n 件衣服，第 i 衣服的湿度为 w_i（保证互不相同），要你求出弄干所有衣服的最少时间（湿度为 0 为干 ）。
输入格式
三个整数，分别为 n,a,b
接下n个数，分别代表w1-wn
输出格式
一行，弄干所有衣服的最少时间。
输入
3 2 1
1
2
3
输出
1
样例解释
让机器烘第三件衣服即可一秒完成。
'''

def test(k):
    sum=0
    for i in range(n):
        re=w[i]-(k*a)
        if(re>0):
            sum+=re/b+(re%b!=0)
    if sum<=k:
        return 1
    else:
        return 0

n,a,b=map(int,input().split())

w=[]
maxr=-1
for i in range(n):
    w.append(int(input()))
    maxr=max(maxr,w[i])
l=1
r=int(maxr/a)
while l<r:
    mid=int((l+r)/2)
    if test(mid):
        r=mid
    else:
        l=mid+1

while test(r)==0:
    r+=1

print(r)

148

'''
148，木材厂有一些原木，现在想把这些木头切割成一些长度相同的小段木头（木头有可能有剩余），需要得到的小段的数目是给定的。
当然，我们希望得到的小段木头越长越好，你的任务是计算能够得到的小段木头的最大长度。木头长度的单位是cm。
原木的长度都是正整数，我们要求切割得到的小段木头的长度也是正整数。
例如有两根原木长度分别为11和21，要求切割成到等长的6段，很明显能切割出来的小段木头长度最长为5.
输入格式
两个正整数N和K，N是原木的数目，K是需要得到的小段的数目。
接下来的N个正整数，表示一根原木的长度。
输出格式
能够切割得到的小段的最大长度。如果连1cm长的小段都切不出来，输出”0”。
输入输出样例
输入
3 7
232
124
456
输出
114

'''

N,K=map(int,input().split())
sum=0
def F(x):
    ans=0
    for i in range(N):
        ans=int(ans+a[i]/x)
    if ans>=K:
        return 1
    else:
        return 0
a=[]
for i in range(N):
    a.append(int(input()))
    sum+=a[i]
if sum<K:
    print(0)
elif sum==K:
    print(1)
elif sum>K:
    l=0
    r=int(sum/K)
    while(l<r):
        mid=int((l+r+1)/2)
        if(F(mid)):
            l=mid
        else:
            r=mid-1
    print(l)