xxx210xxxx: HW9
bytecount: {'code': 448, 'const': 134, 'code+const': 582}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans=[]
  for a in senders:
    if a in receivers:
      for b in receivers[a]:
        ans.append(address[b])
  return ans
def get_item_count(sending_addresses) :
  ans=dict()
  for a in sending_addresses:
    if not a in ans:
      ans[a]=1
    else:
      ans[a]+=1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  ans=dict()
  for a in senders:
    x=[a]
    y=get_sending_addresses(x,receivers,address)
    dis=0
    for b in y:
      dis+=get_distance(b,dispatch_center_addr)
    raka=dis*2
    if dis>10:
      raka+=(dis-10)
    r=raka
    for c in range(0,dis+1):
      if c in discount:
        r=raka-discount[c]
    if r<0:
      r=0
    ans[a]=r
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans=[]
  for a in dispatch_centers:
    x=calculate_fee(senders,receivers,address,discount,dispatch_centers[a])
    c=0
    for b in x.values():
      c+=b
    ans.append([c,a])
  ans=sorted(ans)
  return [ans[0][1],ans[0][0]]

xxx042xxxx: HW9
bytecount: {'code': 446, 'const': 148, 'code+const': 594}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  receive_lst = []
  for e in senders:
    if e in receivers:
      for n in receivers[e]:
        receive_lst.append(address[n])
  return receive_lst
def get_item_count(sending_addresses) :
  sending_dict = {}
  for e in sending_addresses:
    if e in sending_dict:
      sending_dict[e] += 1
    else:
      sending_dict[e] = 1
  return sending_dict
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  all_senders_fee = {}
  for e in senders:
    fee = 0
    d = 0
    if e in receivers:
      for n in receivers[e]:
        d += get_distance(address[n], dispatch_center_addr)
        if d <= 10:
          fee = d * 2
        else:
          fee = 20 + (d-10)*3
      minus = 0
      for p in discount:
        if d >= p:
          minus = discount[p]
      fee -= minus
      if fee < 0:
        fee = 0
    all_senders_fee[e] = fee
  return all_senders_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  dispatch_lst = []
  for e in dispatch_centers:
    s = 0
    fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    for n in fee:
      s += fee[n]
    dispatch_lst.append([s, e])
  dispatch_lst.sort()
  min_fee = [dispatch_lst[0][1], dispatch_lst[0][0]]
  return min_fee

xxx030xxxx: HW9
bytecount: {'code': 478, 'const': 134, 'code+const': 612}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  li_add_of_re = []
  for sender in senders:
    if sender in receivers:
      li_re = receivers[sender]
      for re in li_re:
        li_add_of_re.append(address[re])
  return li_add_of_re
def get_item_count(sending_addresses) :
  d = {}
  for add in sending_addresses:
    if add not in d:
      d[add] = sending_addresses.count(add)
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d_fee = {}
  for send in senders:
    if send not in receivers:
      d_fee[send] = 0
    else:
      li_add = get_sending_addresses([send], receivers, address)
      total_dis = 0
      for add_re in li_add:
        total_dis += get_distance(add_re,  dispatch_center_addr)
      price = 0
      if total_dis <= 10:
        price = 2*total_dis
      else:
        price = 2*10 + 3*(total_dis-10)
      li_discount = [] ; dis_price = 0 ; maxx = 0
      for key in discount:
        if key <= total_dis and key > maxx:
          dis_price = discount[key]
          maxx = key
      price -= dis_price
      if price < 0:
        price = 0
      d_fee[send] = price
  return d_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  li_fee_per_dispatch = []
  for dispatch in dispatch_centers:
    sum_per_dispacth = 0
    dispatch_center_addr = dispatch_centers[dispatch]
    d_fee = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
    for key in  d_fee:
      sum_per_dispacth += d_fee[key]
    li_fee_per_dispatch.append([sum_per_dispacth , dispatch ])
  li_fee_per_dispatch.sort()
  return [li_fee_per_dispatch[0][1] , li_fee_per_dispatch[0][0]]

xxx121xxxx: HW9
bytecount: {'code': 460, 'const': 161, 'code+const': 621}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  add = []
  for i in senders:
    if i in receivers:
      for j in receivers[i]:
        add.append(address[j])
  return add
def get_item_count(sending_addresses) :
  count = {}
  for i in sending_addresses:
    if i not in count:
      count[i] = 1
    else:
      count[i] += 1
  return count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  pay = {}
  for i in senders:
    if i not in receivers:
      pay[i] = 0
    else:
      distance = 0
      for j in get_sending_addresses([i], receivers, address):
        distance += get_distance(j, dispatch_center_addr)
      if distance > 10:
        cost = 10*2 + (distance-10)*3
      else:
        cost = distance*2
      max_dis = 0
      for j in discount:
        if distance >= j:
          max_dis = discount[j]
      if max_dis > cost:
        pay[i] = 0
      else:
        pay[i] = cost - max_dis
  return pay
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  total_min = ''
  for i in sorted(dispatch_centers):
    total_pay = 0
    pay = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    for j in pay:
      total_pay += pay[j]
    if total_min == '':
      total_min = total_pay
      best = i
    elif total_pay < total_min:
      total_min = total_pay
      best = i
  location = [best,total_min]
  return location

xxx209xxxx: HW9
bytecount: {'code': 482, 'const': 148, 'code+const': 630}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  out=[]
  for i in senders:
    re=receivers.get(i)
    if re!=None:
      for j in re:
        out.append(address[j])
  return out
def get_item_count(sending_addresses) :
  item={}
  for i in sending_addresses:
    if i in item:
      item[i]+=1
    else:
      item[i]=1
  return item
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  out={}
  for i in senders:
    km=0
    money=0
    if i in receivers:
      for j in receivers[i]:
        km+=get_distance(address[j],dispatch_center_addr)
      if km<=10: money=km*2
      else: money=10*2+(km-10)*3
      for m in sorted(discount.keys())[::-1]:
        if m <= km:
          money-=discount[m]
          break
    if money < 0:money=0
    out[i]=money
  return out
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  money={}
  min_money={}
  for i in dispatch_centers:
    to=sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]).values())
    money[i]=to
  min=sorted(money.values())[0] 
  for i in money:
    if money[i]==min:
      min_money[i]=min
  out=sorted(min_money.keys())[0]
  return [out,money[out]]

xxx202xxxx: HW9
bytecount: {'code': 446, 'const': 188, 'code+const': 634}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ads=[]
  for i in senders:
    if i in receivers:
      for j in receivers[i]:
        ads.append(address[j])
  return ads
def get_item_count(sending_addresses) :
  itm={}
  for i in sending_addresses:
    if i not in itm:
      itm[i]=1
    else:
      itm[i]+=1
  return itm
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  cal={}
  for i in senders:
    count,pay,d=0,0,0
    for j in get_sending_addresses([i], receivers, address):
      count+=get_distance(j, dispatch_center_addr)
    if count<=10: pay=count*2
    else: pay=20+((count-10)*3)
    for k in discount:
      if count>=k: d=discount[k]
      else: break
    pay-=d
    if pay<0: pay=0
    cal[i]=pay
  return cal
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  best=[]
  for i in dispatch_centers:
    count=0
    cal=calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    for j in cal:
      count+=cal[j]
    best.append([count,i])
  best.sort()
  best_l=[best[0][1],best[0][0]]
  return best_l

xxx211xxxx: HW9
bytecount: {'code': 490, 'const': 146, 'code+const': 636}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  y=[]
  for i in senders:
    if i in receivers:
      x=receivers[i]
      for e in x:
        y.append(address[e])
  return y
def get_item_count(sending_addresses) :
  x={}
  for i in sending_addresses:
    x[i]=0
  for e in sending_addresses:
    x[e]+=1
  return x
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  price=0
  distance=0
  a={}
  d=0
  for i in senders:
    x=get_sending_addresses([i], receivers, address)
    if x==[]:
      price=0
    else:
      for e in x:
        distance+=get_distance(e, dispatch_center_addr)
      if distance<=10:
        price+=2*distance
      else:
        price+=20+((distance-10)*3)
      for j in discount:
        if distance >= j:
          d = discount[j]
      price -= d
      if price<0:
        price=0 
    a[i]=price
    price=0
    distance=0
  return a
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  a=[]
  test = {}
  for i in dispatch_centers:
    test[i] = sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]).values())
  least = min(test.values())
  for j in test:
    if test[j] == least:
      a.append(j)
  a.sort()    
  return [a[0],least]

xxx200xxxx: HW9
bytecount: {'code': 490, 'const': 148, 'code+const': 638}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    n=[]
    r=[]
    for s in senders:
        if s in receivers:
            r+=receivers[s]
    for x in r:
        n.append(address[x])
    return n
def get_item_count(sending_addresses) :
    d={}
    for x in sending_addresses:
        if x in d:
            d[x]+=1
        else: d[x]=1
    return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    fee={}
    for s in senders:
        n=[]
        r=[]
        if s in receivers:
            r+=receivers[s]
        for x in r:
            n.append(address[x])
        d=0
        for i in n:
            d+=get_distance(dispatch_center_addr, i)
        if d<=10: m=d*2
        else: m=20+((d-10)*3)
        dc=0
        for y in discount:
            if d>=y:
                dc=discount[y]
        m-=dc
        if m<0: m=0
        fee[s]=m
    return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    s=[]
    sendlocation=[]
    for dpa in dispatch_centers:
        karsong=0
        c=calculate_fee(senders, receivers, address, discount, dispatch_centers[dpa])
        for z in c:
            karsong+=c[z]
        sendlocation.append([karsong,[dpa,karsong]])
    sendlocation.sort()
    s=sendlocation[0][1]
    return s

xxx206xxxx: HW9
bytecount: {'code': 498, 'const': 140, 'code+const': 638}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  address_list = []
  for sender in senders:
    if sender in receivers:
      targets = receivers[sender]
      for target in targets:
        if target in address:
          address_list.append(address[target])
  return address_list
def get_item_count(sending_addresses) :
  counter_dict = dict()
  for address in sending_addresses:
    if address in counter_dict:
      counter_dict[address] += 1
    else:
      counter_dict[address] = 1
  return counter_dict
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  cost_dict = dict()
  for sender in senders:
    if sender in receivers:
      send_dis = 0
      for receiver in receivers[sender]:
        send_dis += get_distance(address[receiver], dispatch_center_addr)
      max_discount = 0
      for d in sorted(discount.keys()):
        if d > max_discount and d <= send_dis:
          max_discount = d
      send_cost = 0
      if send_dis <= 10:
        send_cost += send_dis * 2
      else:
        send_cost += (send_dis * 3) - 10
      if max_discount in discount:
        cost_dict[sender] = send_cost - discount[max_discount]
      else:
        cost_dict[sender] = send_cost
      cost_dict[sender] = max(cost_dict[sender], 0)
    else:
      cost_dict[sender] = 0
  return cost_dict
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  min_cost = 9999999999999999
  min_area = []
  for area in dispatch_centers:
    cost = sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[area]).values())
    if cost < min_cost:
      min_cost = cost
      min_area = [area]
    elif cost == min_cost:
      min_area += [area]
  return [sorted(min_area)[0], min_cost]

xxx036xxxx: HW9
bytecount: {'code': 494, 'const': 148, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    nameOut = []
    addressOut = []
    for theSender in senders :
        if theSender in receivers :
            nameOut += receivers[theSender]
    for theReceiver in nameOut :
        if theReceiver in address :
            addressOut.append(address[theReceiver])
    return addressOut
def get_item_count(sending_addresses) :
    addressOut = {}
    for address in sending_addresses :
        if address in addressOut : addressOut[address] += 1
        else : addressOut[address] = 1
    return addressOut
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    outFee = {}
    for theSender in senders :
        if theSender in receivers :
            theReceiverList = receivers[theSender]
            theDistance = 0
            theFee = 0
            for theReceiver in theReceiverList : theDistance += get_distance(address[theReceiver],dispatch_center_addr)
            if theDistance <= 10 : theFee += 2*theDistance
            else : theFee += 20 + 3*(theDistance-10)
            discountAble = {}
            for theDiscountDistance in discount :
                if theDiscountDistance <= theDistance : discountAble[theDiscountDistance] = discount[theDiscountDistance]
            if discountAble : theFee -= discountAble[max(discountAble)]
            if theFee < 0 : theFee = 0
            outFee[theSender] = theFee
        else : outFee[theSender] = 0
    return outFee   
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    DispatchCenterList = []
    for theDispatchCenter in dispatch_centers :
        sumFee = 0
        feeDict = calculate_fee(senders, receivers, address, discount, dispatch_centers[theDispatchCenter])
        for theSender in feeDict : sumFee += feeDict[theSender]
        DispatchCenterList.append([sumFee,theDispatchCenter])
    DispatchCenterList.sort()
    return DispatchCenterList[0][::-1]

xxx040xxxx: HW9
bytecount: {'code': 494, 'const': 148, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  r = []
  r_add = []
  for e in senders:
    if e in receivers:
      r += receivers[e]
  for k in r:
    r_add.append(address[k])
  return r_add
def get_item_count(sending_addresses) :
  r_add = {}
  for q in sending_addresses:
    if q in r_add:
      r_add[q] += 1
    else:
      r_add[q] = 1
  return r_add
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for s in senders:
    all_r_add = get_sending_addresses([s], receivers, address)
    distance = 0
    for r in all_r_add:
      distance += get_distance(r,dispatch_center_addr)
    cost = 0
    if distance > 10:
      cost += 10*2 + (distance-10)*3
    else:
      cost += distance*2
    dist_disc = []
    for d in discount:
      dist_disc.append(d)
    dist_disc.sort()
    max_d = 0
    for q in dist_disc:
      if distance >= q:
        max_d = discount[q]
    cost -= max_d
    if cost <0:
      cost = 0
    fee[s] = cost
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  cost = []
  for q in dispatch_centers:
    all_cost = calculate_fee(senders, receivers, address, discount, dispatch_centers[q])
    s = 0
    for z in all_cost:
      s += all_cost[z]
    cost.append([s,q])
  cost.sort()
  return cost[0][::-1]

xxx040xxxx: HW9
bytecount: {'code': 480, 'const': 162, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  addresses = []
  for sender_name in senders :
    if sender_name in receivers :
         for receiver_name in receivers[sender_name] :
           addresses.append(address[receiver_name])
  return addresses
def get_item_count(sending_addresses) :
  item_count = {}
  for address in sending_addresses :
      if address in item_count :
          item_count[address] += 1
      else :
          item_count[address] = 1 
  return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee_of_each_sender = {}
  for sender_name in senders :
    addresses = get_sending_addresses([sender_name], receivers, address) 
    distance = 0
    for add_of_receivers in addresses :
      distance += get_distance(add_of_receivers, dispatch_center_addr)
    fee = 0
    if distance >= 10 :
      fee += 20 +  (distance-10)*3
    else :
      fee += distance*2
    dis = 0
    find_distance = []
    for distance_for_getting in discount :
      if distance >= distance_for_getting :
           find_distance.append(distance_for_getting)
    find_distance.sort()
    if find_distance != [] :   
       dis = discount[find_distance[-1]]
    total = fee-dis
    if total < 0 :
       total = 0      
    fee_of_each_sender[sender_name] = total
  return fee_of_each_sender
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  dispatch_center_and_fee = []
  for a_dispatch_center in dispatch_centers :
   fee_of_each_a_dispatch_center = 0
   fee_of_each_sender = calculate_fee(senders, receivers, address, discount, dispatch_centers[a_dispatch_center])    
   for fee in fee_of_each_sender :
    fee_of_each_a_dispatch_center += fee_of_each_sender[fee]
   dispatch_center_and_fee.append([fee_of_each_a_dispatch_center,a_dispatch_center])
  dispatch_center_and_fee.sort()
  return dispatch_center_and_fee[0][::-1]

xxx043xxxx: HW9
bytecount: {'code': 442, 'const': 200, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    li = []
    for i in senders:
        if receivers.get(i,"")!="":
            for j in receivers[i]:
                li.append(address[j])
    return li
def get_item_count(sending_addresses) :
    d1 = {}
    for i in sending_addresses:
        d1[i] = 0
    for i in sending_addresses:
        d1[i] += 1
    return d1
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    d1 = {}
    for i in senders:
        if receivers.get(i,"")!="":
            dis = 0
            for j in receivers[i]:
                dis += get_distance(dispatch_center_addr, address[j])
            val = dis*2+max(dis-10,0)
            ts = -1
            re = 0
            for j in discount.keys():
                if dis>=j and ts<j:
                    ts = j
                    re = discount[j]
            d1[i]=max(val-re,0)
        else:
            d1[i]=0
    return d1
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    li = []
    for i in dispatch_centers.keys():
        ss = sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]).values())
        li.append([ss,i])
    li.sort()
    return li[0][::-1]

xxx203xxxx: HW9
bytecount: {'code': 480, 'const': 162, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  out = []
  for i in senders:
    if i in receivers:
      for j in receivers[i]:
        out.append(address[j])
  return out
def get_item_count(sending_addresses) :
  d = {}
  for i in sending_addresses:
    if i in d:
      d[i] += 1
    else:
      d[i] = 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  for i in senders:
    if i in receivers:
      distance = fee = 0
      for j in receivers[i]:
        distance += get_distance(address[j],dispatch_center_addr)
      for k in sorted(list(discount.keys()))[::-1]:
        if distance >= k:
          fee -= discount[k]
          break
      if distance >= 10:
        distance -= 10
        fee += 10*2 + distance*3
      else:
        fee += distance*2
      if fee < 0:
        fee = 0
      d[i] = fee
    else:
      d[i] = 0
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  data = []
  for i in dispatch_centers:
    a = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])  
    total = 0
    for j in a:
      total += a[j]
    data.append([total,i])
  data.sort()
  return [data[0][1],data[0][0]]

xxx205xxxx: HW9
bytecount: {'code': 494, 'const': 148, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  kep = []
  for i in senders:
    if i in receivers.keys():
      for val in receivers[i]:
        kep.append(address[val])
  return(kep)
def get_item_count(sending_addresses) :
  count = 0
  kep = {}
  for num in sending_addresses:
    if num not in kep.keys():
      kep[num] = 1
    else:
      kep[num] += 1
  return kep
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  return_dict = {}
  for sender in senders:
    if sender in receivers:
      receiver = receivers[sender]
      sum_cash = 0
      sum_distance = 0
      for re in receiver:
        temp = get_distance(address[re],dispatch_center_addr)
        sum_distance += temp
      if sum_distance <= 10:
          sum_cash = sum_distance*2
      elif sum_distance > 10 :
        sum_cash = (10*2) + ((sum_distance-10)*3)
      temp_2 = list(discount.keys())
      temp_2.reverse()
      for disc in temp_2:
        if sum_distance >= disc:
          sum_cash -= discount[disc]
          break
      if sum_cash <=0:
        sum_cash = 0
      return_dict[sender] = sum_cash
    else:
      return_dict[sender] = 0
  return return_dict
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  kep = {}
  for i,j in dispatch_centers.items():
    kep[i] = sum(calculate_fee(senders, receivers, address, discount, j).values())
  ans = min([[l,m] for m,l in kep.items()])[::-1]
  return ans

xxx211xxxx: HW9
bytecount: {'code': 480, 'const': 162, 'code+const': 642}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  out=[]
  for sendername in senders:
    if sendername in receivers:
      listreceiver=receivers[sendername]
      for receivername in listreceiver:
        out.append(address[receivername])
  return out
def get_item_count(sending_addresses) :
  out={}
  for housenum in sending_addresses:
    if housenum in out:
      out[housenum]+=1
    else:
      out[housenum]=1
  return out
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  out={}
  for sendername in senders:
    totaldistance=0
    if sendername in receivers:
      listreceiver=receivers[sendername]
      for receivername in listreceiver:
        distance=get_distance(address[receivername],dispatch_center_addr)
        totaldistance+=distance
      if totaldistance <=10:
        price=2*totaldistance
      else:
        price=20+3*(totaldistance-10)
      maxkey=-1
      for key in discount:
        if key<=totaldistance and key>maxkey:
          maxkey=key
      if maxkey!=-1:
        discounted=price-discount[maxkey]
      else:  
        discounted=price
      out[sendername]=max(0,discounted)
    else:
      out[sendername]=0
  return out
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  pricelist=[]
  for key in dispatch_centers:
    dispatch_center_addr=dispatch_centers[key]
    pricedict=calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
    totalprice=0
    for name in pricedict:
      totalprice+=pricedict[name]
    pricelist.append([totalprice,key])
  pricelist.sort()
  selected=pricelist[0]
  return [selected[1],selected[0]]

xxx203xxxx: HW9
bytecount: {'code': 500, 'const': 148, 'code+const': 648}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    add = []
    for e in senders:
            if e in receivers:
                for f in receivers[e]:
                    add.append(f)
    list = []
    for g in add:
            list.append(address[g])
    return list
def get_item_count(sending_addresses) :
    d = {}
    for e in sending_addresses:
        if e not in d:
            d[e]=1
        else:
            d[e]+=1
    return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    d = {}
    for e in senders:
        d[e]=0
    for k in receivers:
        if k in senders:
            dt = 0
            s = 0
            for m in receivers[k]:
                dt += get_distance(dispatch_center_addr,address[m])
            if dt<=10:
                s = dt*2
            else:
                s = 20+(dt-10)*3
            dc = 0
            for c in discount:
                if c<=dt:
                    dc=discount[c]
            ss = s-dc
            if ss<0:
                ss=0
            d[k]+=ss
    return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  best = []
  for k in dispatch_centers:
      d = calculate_fee(senders, receivers, address, discount, dispatch_centers[k])
      s = 0
      for m in d:
          s += d[m]
      best.append([s,k])
  best.sort()
  return [best[0][1],best[0][0]]

xxx032xxxx: HW9
bytecount: {'code': 430, 'const': 222, 'code+const': 652}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address):
    res = []
    for sender in senders:
        if sender in receivers:
            for receiver in receivers[sender]:
                res.append(address[receiver])
    return res
def get_item_count(sending_addresses):
    d = {}
    for address in sending_addresses:
        if address in d:
            d[address] += 1
        else:
            d[address] = 1
    return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr):
    d = {}
    for sender in senders:
        d[sender] = 0
        if sender in receivers:
            total_distance = 0
            for receiver in receivers[sender]:
                total_distance += get_distance(
                    address[receiver], dispatch_center_addr)
            if total_distance > 10:
                price = 20 + 3 * (total_distance - 10)
            else:
                price = total_distance * 2
            for ele in sorted(discount, reverse=True):
                if ele <= total_distance:
                    price -= discount[ele]
                    break
            if price > 0:
                d[sender] = price
    return d
def find_best_location(senders, receivers, address, discount, dispatch_centers):
    center2totalFee = {}
    for name, dispatch_center_addr in dispatch_centers.items():
        totalFee = sum(calculate_fee(senders, receivers, address, discount, dispatch_center_addr).values())
        center2totalFee[name] = totalFee
    res = list(min(center2totalFee.items(), key=lambda t: t[::-1]))
    return res

xxx024xxxx: HW9
bytecount: {'code': 524, 'const': 134, 'code+const': 658}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    listreceiver=[]
    sendingAddress=[]
    for k in senders:
        if receivers.get(k)!=None:
            listreceiver+=receivers.get(k)
    for k in listreceiver:
        sendingAddress.append(address.get(k))
    return sendingAddress
def get_item_count(sending_addresses) :
    itemCount={}
    for i in sending_addresses:
        if itemCount.get(i)==None:
            itemCount[i]=sending_addresses.count(i)
    return itemCount
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    calculateFee={}
    for i in senders:
        if receivers.get(i)==None:
            calculateFee[i]=0
        else:
            listi=[i] 
            sendingAddress=get_sending_addresses(listi,receivers,address) 
            distance=0
            for receiverAddress in sendingAddress:
                distance+=get_distance(receiverAddress,dispatch_center_addr)
            if distance<=10:
                cost=distance*2
            else:
                cost=10*2+(distance-10)*3
            discountKeys=list(discount.keys())
            getdiscount=0
            for j in range(len(discountKeys)):
                if discountKeys[j]>distance:
                    break
                getdiscount=discount[discountKeys[j]]
            if cost-getdiscount<=0:
                calculateFee[i]=0
            else:
                calculateFee[i]=cost-getdiscount
    return calculateFee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    calculatefee=[]
    for i in dispatch_centers:
        sum=0
        feePerDispatchCenter=calculate_fee(senders, receivers, address, discount,dispatch_centers.get(i))
        for fee in feePerDispatchCenter:
            sum+=feePerDispatchCenter.get(fee)
        calculatefee.append([sum,i])
    calculatefee.sort()
    return [calculatefee[0][1],calculatefee[0][0]]

xxx215xxxx: HW9
bytecount: {'code': 522, 'const': 136, 'code+const': 658}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  return [address[j] for i in senders if i in receivers for j in receivers[i]]
def get_item_count(sending_addresses) :
  dans = {}
  for add in sending_addresses:
    if add in dans :
      dans[add] += 1
    else :
      dans[add] = 1  
  return dans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  re_ans = {}
  dis_ans = {}
  for i in senders :
    pay = 0
    if i in receivers :
      distancepay = sum([get_distance(address[j], dispatch_center_addr) for j in receivers[i]])
      if distancepay > 10 :
        pay = (10*2) + ((distancepay-10)*3)
      else :
        pay = distancepay*2    
      dis_ans[distancepay] = 0
      for k in sorted(discount)[::-1] :
        if distancepay >= k :
          dis_ans[distancepay] = discount[k]
          break
      if pay - dis_ans[distancepay] >= 0 :
        re_ans[i] = pay - dis_ans[distancepay]
      else :
        re_ans[i] = 0
    else :
      re_ans[i] = 0
  return re_ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  find_ans = {logic:sum(calculate_fee(senders, receivers, address, discount , dispatch_centers[logic]).values()) for logic in dispatch_centers}
  for add in sorted(find_ans) :
    if find_ans[add] == min(find_ans.values()) :
      return[add,min(find_ans.values())]
      break

xxx029xxxx: HW9
bytecount: {'code': 514, 'const': 148, 'code+const': 662}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  l = []
  for i in senders:
    if i in receivers:
      for e in receivers[i]:
        if e in address:
          l.append(address[e])
  return l
def get_item_count(sending_addresses) :
  p = {}
  for i in sending_addresses:
    if i not in p:
      p[i] = 1
    else:
      p[i]+=1
  return p
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  p = {}
  for i in senders:
    p[i] = 0
  x = sorted(discount.items())
  for j in p:
      dis = 0
      s = 0
      promo = 0
      if j in receivers:
          for i in receivers[j]:
              if i in address:
                  dis += get_distance(address[i],dispatch_center_addr)
      for km,fee in x:
          if km <= dis:
              promo = fee       
      if dis <= 10:
          s+= dis*2
      else:
          s+= 20
          dis = dis - 10
          s+= dis*3
      s = s - promo
      if s < 0: s = 0 
      p[j] += s
  return p
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  l=[]
  h=[]
  for e in dispatch_centers:
    s = 0
    d = calculate_fee(senders, receivers, address, discount,dispatch_centers[e] )
    for i in d:
      s+= d[i]
    l.append([s,e])
  l.sort()
  return l[0][::-1]

xxx016xxxx: HW9
bytecount: {'code': 518, 'const': 148, 'code+const': 666}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  asd = []
  qwe = []
  for i in senders:
      if i in receivers:
          asd += receivers[i]
  for i in asd:
      if i in address:
          qwe += [address[i]]
  return qwe
def get_item_count(sending_addresses) :
  asd = {}
  for i in sending_addresses:
      if i not in asd:
          asd[i] = 1
      else:
          asd[i] += 1
  return asd
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  distance1 = 0
  distance2 = []
  list = {}
  dc = 0
  fee = 0
  for i in senders:
      if i in receivers:
          distance2 = get_sending_addresses([i],receivers,address)
          for j in distance2:
              distance1 += get_distance(j,dispatch_center_addr)
              if distance1 >= 10:
                fee = 10*2 + (distance1-10)*3
              else:
                fee = distance1*2
          for k in discount:
            if distance1 >= k:
                dc = discount[k]
          fee -= dc
          if fee < 0:
              fee = 0
          list[i] = fee
          distance1 = 0
      else:
          list[i] = 0
  return list
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  totes = 0
  list = {}
  list2 = []
  for i in dispatch_centers:
    fee_list = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    for j in fee_list:
      totes += fee_list[j]
    list[i] = totes
    totes = 0
  for i in list:
    list2 += [[list[i],i]] 
  list2.sort()
  return list2[0][-1::-1]

xxx021xxxx: HW9
bytecount: {'code': 450, 'const': 216, 'code+const': 666}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    res = []
    for s in senders:
        if s in receivers:
            for r in receivers[s]:
                res.append(address[r])
    return res
def get_item_count(sending_addresses) :
    freq = {}
    for addr in sending_addresses:
        if addr not in freq:
            freq[addr] = 0
        freq[addr] += 1
    return freq
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    fees = {}
    for s in senders:
        fees[s] = 0
        if s in receivers:
            fee = 0
            d = 0
            for r in receivers[s]:
                d += get_distance(address[r], dispatch_center_addr)
            if d <= 10:
                fee = 2 * d
            else:
                fee = 20 + 3 * (d - 10)
            disc = 0
            for km in sorted(discount, reverse=True):
                if km <= d:
                    disc = discount[km]
                    break
            fee -= disc
            fee = max(fee, 0)
            fees[s] = fee
    return fees
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    minc, minf = None, None
    for center, center_addr in dispatch_centers.items():
        f = sum(
            calculate_fee(senders, receivers, address, discount, center_addr).values()
        )
        if minf is None or f < minf:
            minf = f
            minc = center
        elif f == minf and center < minc:
            minc = center
    return [minc, minf]

xxx023xxxx: HW9
bytecount: {'code': 506, 'const': 162, 'code+const': 668}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  lst = []
  for e in senders :
      if e in receivers :
          for p in receivers[e] :
              if p in address :
                  lst.append(address[p])
  return lst
def get_item_count(sending_addresses) :
  r = {}
  for e in sending_addresses :
      if e in r :
          r[e] += 1
      else :
          r[e] = 1
  return r
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  alls = {}
  for e in senders :
      if e in receivers :
          dst = 0
          for p in receivers[e] :
              dst += get_distance(address[p],dispatch_center_addr)
          if dst <= 10 :
              price = 2*dst
          elif dst > 10 :
              price = 20 + 3*(dst - 10)
          disc = []
          for km in discount :
              disc.append([km,discount[km]])
          disc.sort()
          for km,dc in disc[::-1] :
              if km <= dst :
                  price -= dc
                  break
          if price < 0 :
              price = 0
          alls[e] = price
      else :
          alls[e] = 0
  return alls
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  compare = []
  for ct in dispatch_centers :
        sum = 0
        alls = calculate_fee(senders, receivers, address, discount, dispatch_centers[ct])
        for p in alls :
            sum += alls[p]
        compare.append([sum,ct])
  compare.sort()
  return compare[0][::-1]

xxx034xxxx: HW9
bytecount: {'code': 508, 'const': 160, 'code+const': 668}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  lst = []
  for e in senders :
      if e in receivers :
          for d in receivers[e] :
              lst.append(address[d])
  return lst
def get_item_count(sending_addresses) :
  dct = {}
  for e in sending_addresses :
      if e in dct :
          dct[e] += 1
      else :
          dct[e] = 1
  return dct
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  dct = {}
  for e in senders :
      lst = get_sending_addresses([e], receivers, address)
      distance = 0
      for f in lst :
          distance += get_distance(f, dispatch_center_addr)
      if distance > 10 :
          price = 10 * 2 + (distance - 10) * 3
      else :
          price = distance * 2
      max = 0
      for g in discount :
          if distance >= g :
              max = g
      if max in discount :
          price -= discount[max]
          if price < 0 :
              price = 0
      dct[e] = price
  return dct
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans = []
  first = True
  for e in dispatch_centers :
      dct = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
      sum = 0
      for f in dct :
          sum += dct[f]
      if first == True :
          min = sum
          ans.append([e, sum])
          first = False
      elif sum < min :
          ans = []
          ans.append([e, sum])
          min = sum
      elif sum == min :
          ans.append([e, sum])
  ans.sort()
  return ans[0]

xxx042xxxx: HW9
bytecount: {'code': 520, 'const': 148, 'code+const': 668}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  rcvaddress = []
  for e in senders:
      if e in receivers:
          for f in receivers[e]:
              if f in address:
                  rcvaddress.append(address[f])
  return rcvaddress
def get_item_count(sending_addresses) :
  count = {}
  for e in sending_addresses:
      if e in count:
          count[e] += 1
      else:
          count[e] = 1
  return count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  bill ={}
  for sen in senders:
      if sen not in receivers:
          bill[sen] = 0
      else:
          price = 0
          total_dis = 0
          for rcv in receivers[sen]:
              dis = get_distance(address[rcv],dispatch_center_addr)
              total_dis += dis
          if total_dis <= 10:
                  price += total_dis * 2
          else:
                  price += 20 + (total_dis-10)*3
          coupon = 0
          for min_dis in discount:
              if total_dis >= min_dis and min_dis > coupon:
                  coupon = min_dis
          if coupon in discount:
              total = price - discount[coupon]
          else:
              total = price
          if total > 0:
              bill[sen] = total
          else:
              bill[sen] = 0
  return bill
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  best_location = []
  x = 1
  for e in dispatch_centers:
      price = 0
      bill = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
      for sen in bill:
          price += bill[sen]
      if x == 1:
          best_location = [price,e]
          x += 1
      else:
          if best_location > [price,e]:
              best_location = [price,e]
  return [best_location[1],best_location[0]]

xxx219xxxx: HW9
bytecount: {'code': 494, 'const': 174, 'code+const': 668}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  all_address = []
  for sender in senders :
      if sender in receivers :
          for receiver in receivers[sender] :
              all_address.append(address[receiver])
  return all_address
def get_item_count(sending_addresses) :
  address_no = {}
  for address in sending_addresses :
      if address in address_no :
          address_no[address] += 1
      else :
          address_no[address] = 1
  return address_no
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  sender_total = {}    
  for sender in senders :
      all_dis = 0
      total = 0
      all_address = get_sending_addresses([sender], receivers, address)
      if all_address != [] : 
          for add in all_address :
              all_dis += get_distance(add,dispatch_center_addr)
          if all_dis <= 10 :
              price = all_dis * 2
          else :
              price = 20 + ((all_dis-10)*3)
          max_distance = [0]
          disc = False
          for dis in discount :
              if dis <= all_dis :
                  max_distance.append(dis)
                  disc = True
          if disc :
              max_distance = max(max_distance)
              total = price - discount[max_distance]
          else :
              total = price
          if total <= 0 :
              total = 0
          sender_total[sender] = total
      else :
          sender_total[sender] = 0
  return sender_total
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  total_city = []
  for city in dispatch_centers :
      total = 0
      dispatch_center_addr = dispatch_centers[city]
      name_fee = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
      for name in name_fee :
          total += name_fee[name]
      total_city.append([total,city])
  total_city.sort()
  return total_city[0][::-1]

xxx202xxxx: HW9
bytecount: {'code': 522, 'const': 148, 'code+const': 670}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    sendto=[]
    for nsend in senders:
        if nsend in receivers:
            for nresive in receivers[nsend]:
                sendto.append(address[nresive])
    return sendto
def get_item_count(sending_addresses) :
    addcount={}
    for i in sending_addresses:
        if i not in addcount:
            addcount[i]=sending_addresses.count(i)
    return addcount
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    alldis={}
    allfee={}
    dis=[]
    for i in discount:
        dis.append(i)
    dis.sort()
    for nsend in senders:
        alldis[nsend]=0
        if nsend in receivers:
            for nresive in receivers[nsend]:
                alldis[nsend]+=get_distance(dispatch_center_addr,address[nresive])
        if alldis[nsend] <= 10:
            allfee[nsend]=alldis[nsend]*2
        else:
            allfee[nsend]=20+(alldis[nsend]-10)*3
        for i in dis[::-1]:
            if i <= alldis[nsend]:
                allfee[nsend]-=discount[i]
                if allfee[nsend] < 0:
                    allfee[nsend]=0
                break
    return allfee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    alltot=[]
    for dispatch_center_name in dispatch_centers:
        tot=0
        dispatch_center_addr=dispatch_centers[dispatch_center_name]
        allfee=calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
        for i in allfee:
            tot+=allfee[i]
        alltot.append([tot,dispatch_center_name])
    alltot.sort()
    cheap=[alltot[0][1],alltot[0][0]]
    return cheap

xxx043xxxx: HW9
bytecount: {'code': 504, 'const': 175, 'code+const': 679}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  x = []
  for e in senders:
      if e in receivers:
          for h in receivers[e]:
              if h in address:
                  x.append(address[h])
  return x
def get_item_count(sending_addresses) :
  y = {}
  for e in sending_addresses:
      if e in y:
          y[e] += 1
      else:
          y[e] = 1
  return y
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  z = {}
  for e in senders:
      c = 0; d = 0
      a = get_sending_addresses([e], receivers, address)
      if a == []:
          z[e] = 0
      else:
          for h in a:
              b = get_distance(h, dispatch_center_addr)
              d += b
          if d <= 10:
              c += d*2
          else:
              c += 20 + (d-10)*3
          s = 0
          for k in discount:
              if d < k:
                  break
              s = discount[k]
          m = c - s
          if m < 0:
              m = 0
          z[e] = m
  return z
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  n = ['',0]; ch = []
  for u in dispatch_centers:
      j = 0
      p = calculate_fee(senders, receivers, address, discount, dispatch_centers[u])
      for t in p:
          j += p[t]
      ch.append([j,u])
  ch.sort()
  n[0] = ch[0][1]; n[1] = ch[0][0]
  return n

xxx016xxxx: HW9
bytecount: {'code': 532, 'const': 148, 'code+const': 680}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  send_to = []
  for name in senders :
    if name in receivers :
      send_to += [address[e] for e in receivers[name]]
  return send_to
def get_item_count(sending_addresses) :
  counter = {}
  for ad in sending_addresses :
    if ad in counter :
      counter[ad] += 1
    else :
      counter[ad] = 1
  return counter
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  counter = {}
  for name in senders :
    if name in receivers :
      d = 0
      for recs in receivers[name] :
        d += get_distance(address[recs], dispatch_center_addr)
      if d <= 10 :
        payment = d*2
      else :
        payment = 10*2 + (d-10)*3
      if d in discount :
        payment -= discount[d]
      else :
        d_l = [e for e in discount if e < d]
        if d_l != [] :
          max_d = max(d_l)
          payment -= discount[max_d]
      if payment < 0 : payment = 0
      if name in counter :
        counter[name] += payment
      else :
        counter[name] = payment
    else :
      counter[name] = 0
  return counter
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  locations = []
  for addr in dispatch_centers :
    counter = calculate_fee(senders, receivers, address, discount, dispatch_centers[addr])
    payments = 0
    for name in counter :
      payments += counter[name]
    locations.append([payments, addr])
  locations.sort()
  return locations[0][::-1]

xxx039xxxx: HW9
bytecount: {'code': 548, 'const': 134, 'code+const': 682}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  number = []
  r = []
  for e in senders:
      if e in receivers:
          r+=receivers[e]
  for e in r:
      number.append(address[e])
  return number
def get_item_count(sending_addresses) :
  send = {}
  for e in sending_addresses:
      if e in send:
          send[e]+=1
      else:
          send[e] = 1
  return send
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  d = 0
  for e in senders:
      if e not in receivers:
          fee[e] = 0
      else:
          fee[e] = 0
          s = 0
          number = get_sending_addresses([e],receivers,address)
          for k in number:
              d = get_distance(k,dispatch_center_addr)
              s+=d
          pay = 0
          if s>10:
              pay+=(10*2 + (s-10)*3)
          else:
              pay+=(s*2)
          dis = 0
          for key in discount:
              if s>=key:
                  dis = discount[key]
          if dis>pay:
              fee[e] = 0
          else:
              fee[e] = (pay-dis)
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  best = []
  all = []
  center = {}
  for key in dispatch_centers:
      pay = 0
      fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[key])
      for keys in fee:
          pay+=fee[keys]
      all.append(pay)
      center[key] = pay
  for key in center:
      if min(all)==center[key]:
          best.append(key)
  best.sort()
  return [best[0],center[best[0]]]

xxx213xxxx: HW9
bytecount: {'code': 536, 'const': 148, 'code+const': 684}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  j = []
  for i in senders:
    if i in receivers:
      b = receivers[i]
      for t in b:
        j.append(address[t])
  return j
def get_item_count(sending_addresses) :
  l = {}
  for i in sending_addresses:
    if i not in l:
      l[i] = 1
    else:
      l[i] += 1
  return l
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  q = {}
  for sender in senders:
    dis = 0
    if sender in receivers:
      whogotten = receivers[sender]
      for got in whogotten:
        homeadgot = address[got]
        dis += get_distance(dispatch_center_addr,homeadgot)
      pay = 0
      if dis <= 10:
        pay += dis*2
      if dis > 10:
        pay = 20 + (dis-10)*3
      j = []
      for o in discount:
        if o <= dis:
          j.append(o)
        else:
          break
      if len(j) > 0:
        t = discount[j[-1]]
        pay -= t
      else:
        pay = pay
      if pay < 0:
        pay = 0
      q[sender] = pay
    else:
      q[sender] = 0
  return q
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  s = {}
  for c in dispatch_centers:
    alli = 0
    e = calculate_fee(senders, receivers, address, discount, dispatch_centers[c])
    for iz in e:
      alli += e[iz]
    s[c] = alli
  x = []
  for u in s:
      x.append([s[u],u])
  x.sort()
  ii,xx = x[0]
  return [xx,ii]

xxx041xxxx: HW9
bytecount: {'code': 538, 'const': 148, 'code+const': 686}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  l=[]
  for i in senders:
    if i in receivers:
      a = receivers[i]
      for j in a:
        l.append(address[j])
    else:
      pass
  return l
def get_item_count(sending_addresses) :
  d = {}
  for i in sending_addresses:
    if i in d:
      d[i] += 1
    else:
      d[i] = 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  sp = {}
  for i in senders:
    s=0
    dc=0
    if i in receivers:
      a = receivers[i]
      for j in a:
        x = address[j]
        s += get_distance(x, dispatch_center_addr)
      if s <= 10:
        price = s*2
      else:
        price = 10*2 + (s-10)*3
      for k in discount:
        if s>=k:
          dc = discount[k]
        else:
          break
      y = price-dc
      if y<0:
        y=0
      sp[i]=y
    else:
      sp[i]=0
  return sp
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  place_price=[]
  price=[]
  result=[]
  for i in dispatch_centers:
    pp=[]
    x = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    s=0
    for j in x:
      s+=x[j]
    pp.append(i)
    pp.append(s)
    place_price.append(pp)
    price.append(s)
  price.sort()
  lowest_price = price[0]
  place_price.sort()
  print(place_price)
  for k in place_price:
    if k[1] == lowest_price:
      return k

xxx028xxxx: HW9
bytecount: {'code': 546, 'const': 142, 'code+const': 688}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  allreceiver = []
  [allreceiver.extend(receivers[sender]) for sender in senders if sender in receivers.keys()]
  return [address[receiver] for receiver in allreceiver if receiver in address.keys()]
def get_item_count(sending_addresses) :
  alladdress = {}
  uniqueaddress = []
  [uniqueaddress.append(add) for add in sending_addresses if add not in uniqueaddress]
  for add in uniqueaddress:
      alladdress[add] = sending_addresses.count(add)
  return alladdress
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  allfee = {}
  for sender in senders:
      sendingadd = get_sending_addresses([sender], receivers, address)
      dist,disc = 0,0
      for add in sendingadd:
          dist += get_distance(dispatch_center_addr,add)
      for km in discount.keys():
          if dist>=km:
              disc = discount[km]
      fee = max(0, 2*min(10,dist) + 3*max(0,dist-10) - disc)
      allfee[sender] = fee
  return allfee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  locationfee = {}
  for k,v in dispatch_centers.items():
      fee = calculate_fee(senders, receivers, address, discount, v)
      locationfee[k] = sum(list(fee.values()))
  least = min(locationfee.values())
  x = [loc for loc in locationfee.keys() if locationfee[loc] == least]
  x.sort()
  return [x[0],least]

xxx039xxxx: HW9
bytecount: {'code': 556, 'const': 134, 'code+const': 690}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  send_to_adress = []
  for e in senders:
      if e in receivers:
          for i in receivers[e]:
              send_to_adress.append(address[i])
  return send_to_adress
def get_item_count(sending_addresses) :
  number_of_packages = {}
  for e in sending_addresses:
      if e in number_of_packages:
          number_of_packages[e] += 1
      else:
          number_of_packages[e] = 1
  return number_of_packages
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  calculated_fee = {}
  discount_list = []
  for a in discount:
      discount_list.append(a)
  for i in senders:
      location = get_sending_addresses([i], receivers, address)
      distance = 0
      for e in location:
          distance += get_distance(e, dispatch_center_addr)
      fee = 0
      if distance >= 10:
          fee += 10*2 + (distance-10)*3
      else:
          fee += distance*2
      affordable_discount = []
      for n in discount_list:
          if n <= distance:
              affordable_discount.append(n)
      if len(affordable_discount) == 0:
          discounted_fee = fee
      else:
          key = max(affordable_discount)
          discounted_fee = fee - discount[key]
      if discounted_fee < 0:
          discounted_fee = 0
      calculated_fee[i] = discounted_fee
  return calculated_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  fee_dict = {}
  for e in dispatch_centers:
      total_fee = 0
      fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
      for a in fee:
          total_fee += fee[a]
      fee_dict[e] = total_fee
  minimum = min(fee_dict.values())
  best_location_contenders = [[key,value] for key, value in fee_dict.items() if value == minimum]
  best_location_contenders.sort()
  return best_location_contenders[0]

xxx043xxxx: HW9
bytecount: {'code': 536, 'const': 154, 'code+const': 690}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    l_add = []
    for e in senders:
        if e in receivers:
            for k in receivers[e]:
                l_add.append(address[k])
    return l_add
def get_item_count(sending_addresses) :
    d = {}
    for k in sending_addresses:
        if k in d:
            d[k] += 1
        else:
            d[k] = 1
    return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    dct = {}
    for e in senders:
        if e in receivers:
            dis = 0
            for k in receivers[e]:
                    dis += get_distance(address[k],dispatch_center_addr)
            if dis > 10:
                pay = 10*2 + (dis-10)*3
            else:
                pay = dis*2
            disc = find_discount(dis,discount)
            final_pay = pay-disc
            if final_pay < 0:
                final_pay = 0
            if e not in dct:
                dct[e] = final_pay
            else:
                dct[e] += final_pay
        else:
            dct[e] = 0
    return dct
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    f_dct = {}
    for k,v in dispatch_centers.items():
        dct = calculate_fee(senders,receivers,address,discount,v)
        s = sum(dct.values())
        f_dct[k] = s
    m = min(f_dct.values())
    n = []
    for k,v in f_dct.items():
        if v == m:
            n.append(k)
    n.sort()
    return [n[0],m]
def find_discount(dis,discount):
    s = sorted(discount)
    c = 0
    for e in s:
        if e <= dis:
            c = discount[e]
        else:
            break
    return c

xxx040xxxx: HW9
bytecount: {'code': 516, 'const': 176, 'code+const': 692}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  deliver=[]
  for i in senders:
    if i in receivers:
      tmp=receivers[i]
      for j in tmp:
        if j in address:
          deliver.append(address[j])
  return deliver
def get_item_count(sending_addresses) :
  item2address={}
  for i in sending_addresses:
    if i in item2address:
      item2address[i]+=1
    else:
      item2address[i]=1
  return item2address
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee_person={}
  for i in senders:
    distance=0
    fee=0
    sending_addresses=get_sending_addresses([i],receivers,address)
    if len(sending_addresses)==0:
      fee_person[i]=0
    else:
      for j in sending_addresses:
        distance+=get_distance(j,dispatch_center_addr)
      if distance>10:
        fee+=10*2
        fee+=(distance-10)*3
      else:
        fee+=distance*2
      while distance not in discount and distance>=0:
        distance-=1
      if distance==-1:
        value=fee
        fee_person[i]=value
      else:
        discountPperson=discount[distance]
        value=fee-discountPperson
      if value < 0:
        value=0
      fee_person[i]=value
  return fee_person
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  city_allfee=[]
  for i in dispatch_centers:
    fee_allPperson=calculate_fee(senders,receivers,address,discount,dispatch_centers[i])
    fee=0
    for j in fee_allPperson:
      fee+=fee_allPperson[j]
    city_allfee.append([fee,i])
  city_allfee.sort()
  return [city_allfee[0][1],city_allfee[0][0]]

xxx213xxxx: HW9
bytecount: {'code': 530, 'const': 162, 'code+const': 692}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans = []
  for i in senders :
      if i in receivers :
          rec = receivers[i]
          for l in rec :
              ans.append(address[l])
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for i in sending_addresses :
      if i in ans :
          ans[i] += 1
      else :
          ans[i] = 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  ans = {}
  disc = []
  for l in discount :
      disc.append([l,discount[l]])
  disc.sort()
  for i in senders :
      dis = 0
      if i in receivers :
          for k in receivers[i] :
              val = address[k]
              di = get_distance(val,dispatch_center_addr)
              dis += di
      else :
          ans[i] = 0
          continue
      disco = 0
      for o in range (len(disc)) :
          if disc[o][0] > dis :
              break
          else :
              disco = disc[o][1]
      if dis > 10 :
          dis = 20 + 3*(dis-10)
      else :
          dis = dis * 2
      if dis-disco >= 0 :
        ans[i] = (dis-disco)
      else :
        ans[i] = 0
  return(ans)
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  data = []
  for i in dispatch_centers :
      cos = 0
      liscos = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
      for k in liscos :
          cos += liscos[k]
      data.append([cos,i])
  data.sort()
  return(data[0][::-1])

xxx032xxxx: HW9
bytecount: {'code': 516, 'const': 180, 'code+const': 696}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  lst = []
  lst2 = []
  for e in senders :
      if e in receivers :
          for k in receivers[e] :
              lst.append(k)
  for e in lst :
      if e in address :
          lst2.append(address[e])
  return lst2
def get_item_count(sending_addresses) :
  d = {}
  for e in sending_addresses :
      if e in d :
          d[e] += 1
      else :
          d[e] = 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  price = 0
  for e in senders :
      d[e] = 0
  for e in senders :
      a = get_sending_addresses([e], receivers, address)
      b = 0
      for i in a :
          b += get_distance(i, dispatch_center_addr)
      if int(b) > 10 :
          price = (b-10)*3 + 10*2
      else :
          price = b*2
      for k in sorted(discount,reverse=True) :
          if k <= b :
              price = price - discount[k]
              break
      if price <= 0 :
          price = 0
      d[e] = price
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  d = {}
  lst = []
  for e in dispatch_centers :
      d[e] = sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[e]).values())
  mn = min(d.values())
  for e in d :
      if d[e] == mn :
          lst.append(e)
  lst2 = sorted(lst)
  return [lst2[0],mn]

xxx036xxxx: HW9
bytecount: {'code': 518, 'const': 182, 'code+const': 700}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  result=[]
  for i in senders:
    if i in receivers:
      for j in receivers[i]:
        if j in address:
          result.append(address[j])
  return result
def get_item_count(sending_addresses) :
  result={}
  for i in sending_addresses:
    if i in result: result[i]+=1
    else: result[i]=1
  return result
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  result={}
  for i in senders:
    if i not in receivers: result[i]=0
    else:
      distance=0;price=0
      for j in receivers[i]:
        if j in address:
          distance+=get_distance(address[j],dispatch_center_addr)
      if distance<=10:
        price+= distance*2
      else:
        price+= 20+(distance-10)*3
      result[i]=price-get_discount(distance,discount)
      if result[i]<0: result[i]=0         
  return result
def get_discount(distance,discount):
  try:
    result=[]
    for i in discount:
      if i <=distance:
        result.append([i,discount[i]])
    result.sort()
    return result[-1][-1]
  except: return 0
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  result=[]
  for i in dispatch_centers:
    result.append([sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]).values()),i])
  result.sort()
  return [result[0][-1],result[0][0]]

xxx025xxxx: HW9
bytecount: {'code': 554, 'const': 148, 'code+const': 702}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    name = []
    ans = []
    for e in senders:
        if e in receivers:
            for a in receivers[e]:
                    name.append(a)
        else:
            pass
    for b in name:
        ans.append(address[b])
    return ans
def get_item_count(sending_addresses) :
    ans = {}
    for e in sending_addresses:
        if e in ans:
            ans[e] += 1
        else:
            ans[e] = 1
    return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    ans = {}
    for e in senders:
        name = get_sending_addresses([e], receivers, address)
        dis = 0
        for a in name:
            dis += get_distance(a,dispatch_center_addr)
        if dis > 10:
            price = ((dis-10)*3)+ 20
        else:
            price = dis*2
        if dis != 0:
            kilo = []
            for b in discount:
                if b <= dis:
                    kilo.append(b)
                else: pass
            if len(kilo) != 0:
                kilomax = max(kilo)
                total = price - discount[kilomax]
            else:
                total = price
            if total < 0 :
                total = 0
            else: pass
        else:
            total = 0
        ans[e] = total
    return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    x = {}
    for e in dispatch_centers:
        price = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        total = 0
        for a in price:
            total += price[a]
        x[e] = total
    proname = []
    for c in x :
        proname.append([x[c],c])
    proname.sort()
    ans = proname[0]
    ans1 = [ans[1],ans[0]]
    return ans1

xxx216xxxx: HW9
bytecount: {'code': 516, 'const': 187, 'code+const': 703}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    sending_addresses = []
    for sender in senders:
        receiver = receivers.get(sender,0)
        if receiver:
            for name in receiver:
                sending_addresses.append( address.get(name))
    return sending_addresses
def get_item_count(sending_addresses) :
    item_count = {}
    for address in sending_addresses:
        if address not in item_count:
            item_count[address] = 0
        item_count[address] += 1
    return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    fee = {}; kilo_discount = 0; payment = 0
    if 0 not in discount.keys():
        discount[0] = 0
    for sender in senders:
        distance = 0; kilo_discount = 0
        sending_addresses = get_sending_addresses([sender], receivers, address)
        item_count = get_item_count(sending_addresses)
        for item_address, amount in item_count.items():
            distance += get_distance(item_address, dispatch_center_addr) * amount
        fee[sender] =+ distance
        for kilometer in sorted(discount.keys()):
            if distance >= kilometer:
                kilo_discount = kilometer
        kilo_discount = discount[kilo_discount]
        payment = min([10, distance])*2 + ( max([10, distance]) - 10 )*3
        payment = max([0, payment - kilo_discount])
        fee[sender] = payment
    return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    best_price = float('inf'); best_location = ''; 
    for center in dispatch_centers.keys():
        sum_fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[center])
        sum_fee = sum( list( sum_fee.values()))
        if sum_fee < best_price :
            best_price = sum_fee
            best_location = center
        elif sum_fee == best_price:
            if center < best_location:
                best_location = center
                best_price = sum_fee
    return [best_location, best_price]

xxx039xxxx: HW9
bytecount: {'code': 556, 'const': 148, 'code+const': 704}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  receivers_name_list=[]
  for e in senders:
    if e in receivers:
      receivers_name_list+=receivers[e]
    else:
      pass
  ans=[]
  for e in receivers_name_list:
    if e in address:
      ans.append(address[e])
  return ans
def get_item_count(sending_addresses) :
  d={}
  for e in sending_addresses:
    if e in d:
      d[e]+=1
    else:
      d[e]=1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d={}
  for e in senders:
    if e in receivers:
      adtosendlist=[]
      for k in receivers[e]:
        if k in address:
          adtosendlist.append(address[k])
      sumdistance=0
      for i in range(len(adtosendlist)):
        sumdistance+=get_distance(adtosendlist[i],dispatch_center_addr)
      if sumdistance>10:
        summoney=10*2+(sumdistance-10)*3
      else:
        summoney=sumdistance*2
      x=0
      for j in discount:
        if j <= sumdistance:
          if j>x:
            x=j
      if x==0:
        totalmoney=summoney
      else:
        totalmoney=summoney-discount[x]
      if totalmoney<0:
        totalmoney=0
      d[e]=totalmoney
    else:
      d[e]=0
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans=[]
  for e in dispatch_centers:
    dispatch_center_addr=dispatch_centers[e]
    d=calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
    s=0
    for k in d:
      s+=int(d[k])
    ans.append([s,e])
  ans.sort()
  print(ans)
  return [ans[0][1],ans[0][0]]

xxx040xxxx: HW9
bytecount: {'code': 556, 'const': 148, 'code+const': 704}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  r = list()
  for i in senders:
    if i in receivers.keys():
      r += receivers[i]
  a = list()
  for i in r:
    if i in address.keys():
      a.append(address[i])
  return a
def get_item_count(sending_addresses) :
  d = dict()
  for i in sending_addresses:
    if i not in d.keys():
      d[i] = 1
    else:
      d[i] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = dict()
  for i in senders:
    if i not in receivers.keys():
      d[i] = 0
    else:
      item = get_item_count(get_sending_addresses([i], receivers, address))
      a = 0
      for j in item.keys():
        a += get_distance(j, dispatch_center_addr) * item[j]
      if a <= 10:
        s = 2*a
      else:
        s = 20 + 3*(a-10)
      m = 0
      for j in discount.keys():
        if min(j,a) == j:
          m = discount[j]
      d[i] = max(0,s-m)
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  n = list()
  m = list()
  for i in dispatch_centers.keys():
    f = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    l = list(f.values())
    n.append([i,sum(l)])
    m.append(sum(l))
  a = []
  for i in n:
    if i[1] == min(m):
      a.append(i)
  return sorted(a)[0]

xxx022xxxx: HW9
bytecount: {'code': 522, 'const': 184, 'code+const': 706}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  out = []
  for i in senders:
    if i in receivers:
      for j in receivers[i]:
        out.append(address[j])
  return out
def get_item_count(sending_addresses) :
  out = {}
  for i in sending_addresses:
    if i not in out:
      out[i] = 1
    else:
      out[i] += 1
  return out
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  out = {}
  for i in senders:
    x = get_sending_addresses([i], receivers, address)
    if len(x) > 0:
      km,fee = 0,0
      for j in x:
        km += get_distance(j, dispatch_center_addr)
      if km > 10:
        fee += 10*2 + (int(km)-10)*3
      else:
        fee += km*2
      disk,disv = 0,0
      for k in discount:
        if km >= k and k > disk:
          disk = k
          disv = discount[k]
      fee = int(fee)-int(disv)
      if fee <= 0:
        fee = 0
      out[i] = fee
    else:
      out[i] = 0
  return out
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  out = []
  for i in dispatch_centers:
    cost = 0
    x = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    for j in x:
      cost += x[j]
    out.append([cost,i])
  out.sort()
  cheapest = []
  cheapest.append(out[0][1])
  cheapest.append(out[0][0])
  return cheapest

xxx036xxxx: HW9
bytecount: {'code': 546, 'const': 162, 'code+const': 708}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  sending_addresses = []
  for e in senders:
      if e in receivers:
          for f in receivers[e]:
              sending_addresses.append(address[f])
  return sending_addresses
def get_item_count(sending_addresses) :
  item_count = {}
  for e in sending_addresses:
      if e in item_count:
          item_count[e] += 1
      else:
          item_count[e] = 1
  return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  senders_fee = {}
  receivers_address = {}
  for e in senders:
      if len(get_sending_addresses([e],receivers,address)) != 0:
          receivers_address[e] = get_sending_addresses([e],receivers,address)
      else:
          senders_fee[e] = 0
  for e in receivers_address:
      distance = 0
      for f in receivers_address[e]:
          distance += get_distance(f,dispatch_center_addr)
      if distance - 10 <= 0:
          fee = distance*2
      else:
          fee = 20 + (distance - 10)*3
      valid_discount = []
      for g in discount:
          if distance >= g:
              valid_discount.append(g)
      valid_discount.sort()
      if len(valid_discount) != 0:
          fee_discounted = discount[valid_discount[-1]]
          if fee_discounted > fee:
              fee = 0
          else:
              fee -= fee_discounted
      senders_fee[e] = fee
  return senders_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  all_center_fee = []
  for e in dispatch_centers:
      dispatch_center_addr = dispatch_centers[e]
      senders_fee = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
      center_fee = 0
      for f in senders_fee:
          center_fee += senders_fee[f]
      all_center_fee.append([center_fee,e])
  all_center_fee.sort()
  best_center = [all_center_fee[0][1],all_center_fee[0][0]]
  return best_center

xxx026xxxx: HW9
bytecount: {'code': 548, 'const': 161, 'code+const': 709}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    l = []
    for s in senders:
        if s in receivers:
            for r in receivers[s]:
                l.append(address[r])
    return l
def get_item_count(sending_addresses) :
    l = {}
    for e in sending_addresses:
        if e not in l: l[e] = 1
        else: l[e] += 1
    return l
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    l = {}
    for s in senders:
        l[s] = 0
        if s in receivers:
            n = 0
            for r in receivers[s]:
                n += get_distance(address[r], dispatch_center_addr)
            if 0 <= n <= 10: l[s] = 2*n
            else: l[s] = 2*10 + (n-10)*3
            D = 0
            for e in discount:
                if e <= n: D = discount[e]
                else: pass
            l[s] = l[s] - D
            if l[s] < 0 : l[s] = 0
    return l
def find_best_location(senders, receivers, address, discount , dispatch_centers) :      
    l = {}
    for location in dispatch_centers:
        s = 0
        x = calculate_fee(senders, receivers, address, discount, dispatch_centers[location])
        for e in x:
            s += x[e]
        l[location] = s
    Min = s ; loca = ''
    for e in l:
        if l[e] < Min:
            Min = l[e]
            loca = e
        elif l[e] == Min:
            if loca == '': loca = e
            else: 
                x = [loca,e]
                x.sort()
                loca = x[0]
    return [loca,Min]

xxx016xxxx: HW9
bytecount: {'code': 564, 'const': 148, 'code+const': 712}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  a=[]
  for i in senders:
    if i in receivers:
      l=receivers[i]
      for j in l:
        a.append(address[j])
  return a
def get_item_count(sending_addresses) :
  a=dict()
  for i in sending_addresses:
    if i in a:
      a[i]=a[i]+1
    else:
      a[i]=1
  return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  a={}
  for i in senders:
    c=0
    if i not in receivers:
      c=0
    else:
      l=get_sending_addresses([i],receivers,address)
      sd=0
      for j in l:
        d=get_distance(j,dispatch_center_addr)
        sd=sd+d
      for x in range(1,sd+1):
        if x<=10:
          c=c+2
        else:
          c=c+3
      dis=0
      sdd=sd
      while sdd>0:
        if sdd in discount.keys():
          dis=discount[sdd]
          break
        else:
          sdd=sdd-1
      c=c-dis
      if c<0:
        c=0
    a[i]=c
  return a
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  a=[]
  for i in dispatch_centers:
    c=calculate_fee(senders,receivers,address,discount,dispatch_centers[i])
    sc=0
    for j in c.values():
      sc=sc+j
    if a==[]:
      a.append([i,sc])
    elif a[0][1]>sc:
      a=[]
      a.append([i,sc])
    elif a[0][1]==sc:
      a.append([i,sc])
  a.sort()
  return a[0]

xxx042xxxx: HW9
bytecount: {'code': 564, 'const': 148, 'code+const': 712}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  hno = []
  for e in senders:
    if e in receivers.keys():
      recv = receivers[e]
      for e in recv:
          hno.append(address[e])
  return hno
def get_item_count(sending_addresses) :
  cnt = {}
  for e in sending_addresses:
    if e not in cnt:
      cnt[e] = 1
    else:
      cnt[e] += 1
  return cnt
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  calc = {}
  for e in senders:
    calc[e] = 0
    ad = get_sending_addresses([e],receivers,address)
    dist = 0
    for b in ad:
      dist += get_distance(b, dispatch_center_addr)
    if dist >= 10:
      calc[e] += 2*10 + (dist-10)*3
    else :
      calc[e] += 2*dist
    for i in range(dist,0,-1):
      if i in discount.keys():
        calc[e] -= discount[i]
        break
  for e in calc.keys():
    if calc[e] < 0:
      calc[e] = 0
  return calc
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  tot = {} ; cp = [] ; badr = []
  for e in dispatch_centers.keys():
    s = 0
    a = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    for c in a.values():
      s += c
    cp.append(s)
    tot[e] = s
  mn = min(cp)
  for e in tot.keys():
    if tot[e] == mn:
      badr.append(e)
  badr.sort()
  return [badr[0],mn]

xxx041xxxx: HW9
bytecount: {'code': 520, 'const': 194, 'code+const': 714}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ad=[]
  for i in senders:
      if i in receivers.keys():
          for i2 in receivers[i]:
              ad.append(address[i2])
  return ad
def get_item_count(sending_addresses) :
  p={}
  for i in sending_addresses:
      if i in p:
          p[i]+=1
      else:
          p[i]=1
  return p
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  p={}
  for i in senders:
      ad=get_item_count(get_sending_addresses([i], receivers, address))
      if len(ad)>0:
          s=0
          dis=0
          for i2 in ad.keys():
              dis+=(get_distance(i2, dispatch_center_addr))*ad[i2]
          if dis>10:
            s+=(20 + (dis-10)*3)
          else:
            s+=(dis*2)
          disc=list(discount.keys())
          disc.sort(reverse=True)
          for i2 in disc:
              if dis>=i2:
                  s-=discount[i2]
                  if s<0 : s=0
                  break
          p[i]=s
      else: p[i]=0
  return p
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  f=[]
  for e in dispatch_centers:
    ss=0
    s=calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    for i in s.values():
        ss+=i
    if ss<0: ss=0
    f.append([ss,e])
  f.sort()
  return f[0][::-1]

xxx043xxxx: HW9
bytecount: {'code': 552, 'const': 162, 'code+const': 714}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address):
  receive_list = []
  result = []
  for sender in senders:
    if sender in receivers:
      receive_list += receivers[sender]
  for receiver in receive_list:
    if receiver in address:
      result.append(address[receiver])
  return result
def get_item_count(sending_addresses):
  result = {}
  for address in sending_addresses:
    if address in result:
      result[address] += 1
    else:
      result[address] = 1
  return result
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr):
  result = {}
  kilos = []
  for kilo in discount:
    kilos.append(kilo)
  kilos.sort()
  kilos = kilos[::-1]
  for sender in senders:
    fee = 0
    total_distance = 0
    if sender in receivers:
      sending_address = get_sending_addresses([sender], receivers, address)
      item_count = get_item_count(sending_address)
      for item in item_count:
        total_distance += get_distance(dispatch_center_addr, item)
      if total_distance <= 10:
        fee += 2*total_distance
      elif total_distance > 10:
        fee += 20 + 3*(total_distance-10)
      for kilo in kilos:
        if total_distance >= kilo:
          fee -= discount[kilo]
          break
      result[sender] = max(fee, 0)
    else:
      result[sender] = 0
  return result
def find_best_location(senders, receivers, address, discount, dispatch_centers):
  center_cost = []
  result = []
  max = 0
  for center in dispatch_centers:
    sum = 0
    for sender in senders:
      sum += calculate_fee([sender], receivers, address, discount, dispatch_centers[center])[sender]
    center_cost.append([sum, center])
  center_cost.sort()
  return [center_cost[0][1], center_cost[0][0]]

xxx009xxxx: HW9
bytecount: {'code': 570, 'const': 148, 'code+const': 718}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  h = []
  for e in senders:
    if e in receivers:
      for k in receivers[e]:
        h.append(address[k])
  return h
def get_item_count(sending_addresses) :
  num = {}
  for e in sending_addresses:
    if e in num:
      num[e] += 1
    else:
      num[e] = 1
  return num
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for e in senders:
    if e in receivers:
      a = get_item_count(get_sending_addresses([e], receivers, address))
      c = 0
      for k in a:
        c += a[k]*(get_distance(k, dispatch_center_addr))
      if c <= 10:
        f = c*2
      elif c > 10:
        f = 10*2 + (c - 10)*3
      d = 0
      for j in discount:
        if c >= j:
          d = discount[j]
        else: break
      if f - d < 0:
        fee[e] = 0
      else:
        fee[e] = f - d
    else:
      fee[e] = 0  
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  center = []
  k = []
  for e in dispatch_centers:
    a = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    c = 0
    q = [e]
    for i in a:
      c += a[i]
    q.append(c)
    k.append(q)
  w = []
  for i in k:
    w.append(i[1])
  x = min(w)
  for i in k:
    if x == i[1]:
      center.append(i)
  center.sort()
  center = center[0]
  return center

xxx024xxxx: HW9
bytecount: {'code': 570, 'const': 148, 'code+const': 718}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  a = []
  for i in senders :
      if i in receivers :
          for e in receivers[i] :
              a.append(e)
  b = []
  for i in a :
      b.append(address[i])
  return b
def get_item_count(sending_addresses) :
  a = {}
  for i in sending_addresses :
      if i in a :
          a[i] += 1
      else :
          a[i] = 1
  return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for i in senders :
      fee[i] = 0
      if i in receivers :
          a = receivers[i]
          b = []
          for j in a :
              b.append(address[j])
          c = 0
          for f in b :
              c += get_distance(f, dispatch_center_addr)
          d = 0
          if c > 10 :
              d += 10*2 + (c-10)*3
          else :
              d += c*2
          maxdis = 0
          for g in discount :
              if c >= g and g > maxdis :
                  maxdis = g
          if maxdis != 0 :
              dis = discount[maxdis]
          else :
              dis = 0
          d -= dis
          if d < 0 :
              d = 0
          if i in fee :
              fee[i] += d
          else :
              fee[i] = d
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  x = []
  for y in dispatch_centers :
      k = 0
      n = calculate_fee(senders, receivers, address, discount, dispatch_centers[y])
      for z in n :
          k += n[z]
      x.append([k,y])
  x.sort()
  return x[0][::-1]

xxx203xxxx: HW9
bytecount: {'code': 556, 'const': 164, 'code+const': 720}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    housenumber=[]
    receive=[]
    for e in senders:
        if e in receivers:
            receive.append(receivers[e])
    receiver=[]
    for e in receive:
        for r in e:
            receiver.append(r)
    for r in receiver:
        if r in address:
            housenumber.append(address[r])
    return housenumber
def get_item_count(sending_addresses) :
    itemcount={}
    for e in sending_addresses:
        if e in itemcount:
            itemcount[e]+=1
        else:
            itemcount[e]=1
    return itemcount
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    pay={}
    for e in senders:
        distance=0
        if e in receivers:
            for r in receivers[e]:
                if r in address:
                    housenum=address[r]
                    distance+=get_distance(dispatch_center_addr,housenum)
            if distance>10:
                money=20+(distance-10)*3
            else:
                money=distance*2
            minus=0
            for dis in discount:
                if dis<=distance:
                    minus=discount[dis]
            money-=minus
            if money<0:
                money=0
            pay[e]=money
        else:
            pay[e]=0
    return pay
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    best=[]
    bestlocate=[]
    minpay=99999999
    for e in dispatch_centers:
        pay=calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        sumpay=0
        for p in pay:
            sumpay+=pay[p]
        if sumpay<=minpay:
            minpay=sumpay
        best.append([e,sumpay])
    best.sort()
    for e in best:
        if e[1]==minpay:
            bestlocate=e
            break
    return bestlocate

xxx037xxxx: HW9
bytecount: {'code': 588, 'const': 134, 'code+const': 722}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  output = []
  r = []
  for name in senders :
      if name in receivers :
          r += receivers[name]
          for e in r :
              if e in address :
                  output.append(address[e])
          r = []
      else :pass
  output.sort()
  return output
def get_item_count(sending_addresses) :
  output = {}
  for home in sending_addresses :
      if home in output :
          output[home] += 1
      else :
          output[home] = 1
  return output
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  cn = {}
  cn1 = {}
  prepay = {}
  c = 0
  for name in senders:
      cn[name] = get_sending_addresses([name], receivers, address)
  for e in cn :
      distance = 0
      for n in cn[e] :
          distance += get_distance(n,dispatch_center_addr)
      cn1[e] = distance
  for m in cn1 :
      if cn1[m] <= 10 :
          prepay[m] = cn1[m] * 2
      else :
          prepay[m] = cn1[m] *3  - 10
  for m in cn1:
      a = 0
      for i in discount:
          if cn1[m] >= i:
              a = discount[i]
      prepay[m] -= a
  for y in prepay :
      if prepay[y] < 0 : prepay[y] = 0
  return prepay
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  loca = []
  ans = []
  for i in dispatch_centers:
    fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    sum = 0
    for j in fee:
      sum += fee[j]
    loca.append([sum,i])
  loca.sort()
  ans = loca
  return ans[0][::-1]

xxx211xxxx: HW9
bytecount: {'code': 518, 'const': 208, 'code+const': 726}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  a = []
  for sender in senders:
    if sender in receivers:
      a += receivers[sender]
  output = []
  for i in a:
    if i in address:
      output.append(address[i])
  return output
def get_item_count(sending_addresses) :
  output = {}
  for i in sending_addresses:
    if i not in output:
      output[i] = 1
    else:
      output[i] += 1
  return output
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  output = {}
  ldiscount = []
  for i in discount:
    ldiscount.append([i, discount[i]])
  ldiscount.sort(reverse=True)
  for sender in senders:
    sending_addresses = get_sending_addresses([sender], receivers, address)
    total_fee = 0
    total_distance = 0
    for sending_address in sending_addresses:
      total_distance += get_distance(sending_address, dispatch_center_addr)
    if total_distance <= 10:
      total_fee += total_distance*2
    else:
      total_fee += 10*2 + (total_distance-10)*3
    for i in ldiscount:
      if total_distance >= i[0]:
        total_fee -= i[1]
        break
    if total_fee < 0:
      total_fee = 0
    output[sender] = total_fee
  return output
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  a = []
  for dispatch_center in dispatch_centers:
    total_fees = 0
    fees = calculate_fee(senders, receivers, address, discount, dispatch_centers[dispatch_center])
    for fee in fees:
      total_fees += fees[fee]
    a.append([total_fees, dispatch_center])
  a.sort()
  return [a[0][1], a[0][0]]

xxx023xxxx: HW9
bytecount: {'code': 500, 'const': 227, 'code+const': 727}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address):
    a = []; r = []
    for e in senders:
        if e in receivers:
            a += receivers[e]
    for e in a:
        r.append(address[e])
    return r
def get_item_count(sending_addresses):
    a = {}
    for e in sending_addresses:
        if e not in a:
            a[e] = 0
        a[e] += 1
    return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr):
    r = {}
    for e in senders:
        a = 0
        gic = get_item_count(get_sending_addresses([e], receivers, address))
        for i in gic:
            a += get_distance(dispatch_center_addr, i) * gic[i]
        if a > 10: price = 10 * 2 + (a - 10) * 3
        else: price = a * 2
        for j in sorted(discount)[::-1]:
            if j <= a: break
        else:
            r[e] = price
            continue
        price -= discount[j]
        if price < 0: price = 0
        r[e] = price
    return r
def find_best_location(senders, receivers, address, discount, dispatch_centers):
    first = True
    result = ['', 0]
    for k in sorted(dispatch_centers):
        a = calculate_fee(senders, receivers, address, discount, dispatch_centers[k])
        b = sum([a[e] for e in a])
        if first:
            result = [k, b]
            first = False
        if b < result[1]:
            result = [k, b]
    return result

xxx045xxxx: HW9
bytecount: {'code': 568, 'const': 162, 'code+const': 730}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  listout = []
  names = []
  for e in senders:
    if e in receivers:
      names += receivers[e]
  for g in names:
    listout.append(address[g])
  return listout 
def get_item_count(sending_addresses) :
  getcount = {}
  for e in sending_addresses:
    if e in getcount:
      getcount[e]+=1
    else:
      getcount[e]=1
  return getcount 
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  totalfee = {}
  for e in senders:
    totalfee[e] = 0
  for the_sender in receivers:
    X = receivers[the_sender]
    distance_sum = 0
    for the_reciever in X :
      the_distance = get_distance(dispatch_center_addr, address[the_reciever])
      distance_sum += the_distance
    if distance_sum >= 10:
      the_fee = (distance_sum-10)*3 + 20
    else:
      the_fee = distance_sum *2 
    the_discount = 0
    maxi = None
    for k in sorted(list((dict.keys(discount)))): 
      if distance_sum >= k:
        maxi = k
    if maxi in discount:
      the_fee -= discount[maxi]
    if the_fee < 0:
      the_fee = 0
    if the_sender in totalfee:
      totalfee[the_sender] += the_fee
  return totalfee 
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  L = []
  for DC in dispatch_centers:
    X = calculate_fee(senders, receivers, address, discount, dispatch_centers[DC])
    sum_of_fee = sum(list(dict.values(X)))
    L.append([DC,sum_of_fee])
  fee_list = [e[1] for e in L]
  cheapest_fee = min(fee_list)
  winner=[]
  for w in L:
    if w[1]==cheapest_fee:
      winner.append(w)
  winner.sort()
  return winner[0]

xxx018xxxx: HW9
bytecount: {'code': 564, 'const': 168, 'code+const': 732}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  send_address = []
  for sender in senders:
    if sender in receivers:
      for receiver in receivers[sender]:
        send_address.append(address[receiver])
  return send_address
def get_item_count(sending_addresses) :
  value_per_address = {}
  for address in sending_addresses:
    if address in value_per_address:
      value_per_address[address] += 1
    else:
      value_per_address[address] = 1 
  return value_per_address
def calculate_price(distance, discount):
  if distance > 10 :
    price = 20 + (distance-10) * 3
  else:
    price = distance * 2
  check = distance
  while len(discount) > 0:
    if check in discount:
      price -= discount[check]
      break
    check -= 1
    if check <= 0:
      break
  if price < 0:
    price = 0
  return price
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  send_fee = {}
  for sender in senders:
    if sender in receivers:
      distance = 0
      for receiver in receivers[sender]:
        distance += get_distance(dispatch_center_addr, address[receiver])
      price = calculate_price(distance, discount)
      if sender in send_fee:
        send_fee[sender] += price
      else:
        send_fee[sender] = price
    else:
      send_fee[sender] = 0
  return send_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  lowest_fee = None
  sum_fee = 0
  closest_center = None
  for center in dispatch_centers:
    sum_fee = 0
    for sender in senders:
      if sender in receivers:
        distance = 0
        for receiver in receivers[sender]:
          distance += get_distance(dispatch_centers[center], address[receiver])
        sum_fee += calculate_price(distance, discount)
    if (lowest_fee == None) or (sum_fee < lowest_fee)     or (sum_fee == lowest_fee and center < closest_center):
      lowest_fee = sum_fee
      closest_center = center
  return [closest_center, lowest_fee]

xxx035xxxx: HW9
bytecount: {'code': 588, 'const': 148, 'code+const': 736}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  S=[]
  for i in senders:
    if i in receivers:
      for j in receivers[i]:
        S.append(address[j])
  return S
def get_item_count(sending_addresses) :
  S={}
  for i in sending_addresses:
    if i not in S:
      S[i]=1
    else:
      S[i]+=1
  return S
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  S={}
  Z=[]
  for z in discount:
    Z.append(z)
  for i in senders:
    g=Z[0:]
    a=0 ; s=0
    sent=get_sending_addresses([i], receivers, address)
    for j in sent:
      a+=get_distance(j,dispatch_center_addr)
    if a>10:
      s=a*2+a-10
    else:
      s=a*2
    if a in g :
      c=a
    else:
      g.append(a)
      g.sort()
      if g.index(a)!=0:
        c=g[g.index(a)-1]
      else:
        c=-1
    if c==-1:
      S[i]=s
    elif s-discount[c]>=0 :
      S[i]=s-discount[c]
    else:
      S[i]=0
  return S
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  C=[]
  for i in dispatch_centers:
    s=0
    v=calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    for j in v:
      s+=v[j]
    if C==[]:
      C=[i,s]
    elif C[1]>s:
      C=[i,s]
    elif C[1]==s:
      C=[sorted([C[0],i])[0],s]
  return C

xxx025xxxx: HW9
bytecount: {'code': 580, 'const': 162, 'code+const': 742}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  receiver_addresses = []
  for sender in senders :
    if sender in receivers :
      for receiver in receivers[sender] :
        receiver_addresses.append(address[receiver])
  return receiver_addresses
def get_item_count(sending_addresses) :
  count_addresses = {}
  for address in sending_addresses :
    if address in count_addresses :
      count_addresses[address] += 1
    else :
      count_addresses[address] = 1
  return count_addresses
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for sender in senders :
    sender = [sender]
    count_addresses = get_item_count(get_sending_addresses(sender, receivers, address))
    if count_addresses == {} :
      fee[sender[0]] = 0
    else :
      distance = 0
      for c_address in count_addresses :
        distance += get_distance(c_address, dispatch_center_addr) * count_addresses[c_address]
      pay = 0
      if distance > 10 :
        pay += (distance-10) * 3 + 20
      else :
        pay += distance * 2
      check = []
      for dist,disc in discount.items() :
        check.append([dist,disc])
      check.sort()
      dis = 0
      for [dist,disc] in check[::-1] :
        if distance >= dist :
          dis = disc
          break
      pay -= dis
      if pay > 0 :
        fee[sender[0]] = pay
      else :
        fee[sender[0]] = 0
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  location = []
  for dispatch_center_name  in dispatch_centers :
    dispatch_center_addr = dispatch_centers[dispatch_center_name]
    fee = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
    sumpay = 0
    for a in fee :
      sumpay += fee[a]
    location.append([sumpay, dispatch_center_name])
  location.sort()
  best_location = [location[0][1],location[0][0]]
  return best_location

xxx024xxxx: HW9
bytecount: {'code': 596, 'const': 148, 'code+const': 744}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  all_receiver = []
  for sender in senders:
      if sender in receivers:
          list_re = receivers[sender]
          for re in list_re:
              all_receiver.append(re)
      else:
            pass
  for j in range(len(all_receiver)):
      if all_receiver[j] in address:
          all_receiver[j] = address[all_receiver[j]]
  return all_receiver
def get_item_count(sending_addresses) :
  item_count = {}
  for address in sending_addresses:
    if address in item_count:
          item_count[address] += 1
    else:
          item_count[address] =1
  return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for sender in senders:
        if sender in receivers:
            receiver = receivers[sender]
            distance = 0
            for i in receiver:
              distance += get_distance(address[i],dispatch_center_addr)
            sale = 0
            for i in discount:
                if distance >= i:
                    sale = discount[i]
            total = 0
            if distance <= 10:
                total = distance*2 - sale
            else:
                total = (10*2)+(distance-10)*3 - sale
            if total < 0:
                fee[sender] = 0
            else:
                fee[sender] = total
        else:
            fee[sender] = 0
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  location_fee = {}
  all_total = []
  for center in dispatch_centers:
        fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[center])
        total = 0
        for f in fee:
            total += fee[f]
        location_fee[center] = total
        all_total.append(total)
  mini = min(all_total)
  best_location = []
  for center in location_fee:
    if location_fee[center] == mini :
      best_location.append([center,mini])
  if len(best_location) != 1:
    best_location.sort()
    best_location = best_location[0]
    ans = [best_location[0],mini]
  else:
    ans = best_location[0]
  return ans

xxx034xxxx: HW9
bytecount: {'code': 596, 'const': 148, 'code+const': 744}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans = []
  for i in receivers:
    if i in senders:
      for j in receivers[i]:
        ans.append(address[j]) 
  return(ans)
def get_item_count(sending_addresses) :
  d = {}
  for i in sending_addresses:
    if i in d:
      d[i] += 1
    else:
      d[i] = 1
  return(d)
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  for sdr in senders:
    rc = get_sending_addresses(sdr, receivers, address)
    s = 0
    for i in rc:
      dis = get_distance(i, dispatch_center_addr)
      s += dis
    if s > 10:
      cost = (10*2)+((s-10)*3)
    elif s<= 10:
      cost = s*2  
    list_dis = []    
    for e in discount:
      if s >= e:
        list_dis.append(e)
    max = 0   
    for j in list_dis:
      if j >= max:
        max = j
    if max in discount:     
      if discount[max] <= cost:
        cost -= discount[max]
      elif discount[max] > cost:
        cost = 0   
    d[sdr] = cost
  return(d)
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  d = {}
  for i in dispatch_centers:
    total = 0
    dc = dispatch_centers[i]
    fee = calculate_fee(senders, receivers, address, discount, dc)
    for e in fee:
      total += fee[e]
    d[i] = total
  c = []  
  for j in d:
    c.append(d[j])
  m = min(c)
  a =[]
  for k in d:
    a.append([k,d[k]])
  a.sort()  
  for e in a:
    if e[1] == m:
      return(e)

xxx205xxxx: HW9
bytecount: {'code': 578, 'const': 168, 'code+const': 746}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  result = []
  for name in senders:
      if name in receivers:
          for reciv in receivers[name]:
              if reciv in address:
                  result.append(address[reciv])
  return result
def postfee(dist):
    if dist <= 10:
        return dist*2
    return 20 + (dist-10)*3
def get_item_count(sending_addresses) :
  send = {}
  for item in sending_addresses:
      if item not in send:
          send[item] = 1
      else:
          send[item] +=1
  return send
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  result={}
  dist={}
  for send in senders:
      if send in receivers:
          for reciv in receivers[send]:
              if send not in dist:
                 dist[send] = get_distance(address[reciv],dispatch_center_addr)
              else:
                  dist[send] += get_distance(address[reciv],dispatch_center_addr)
      else:
          result[send] = 0
  for add in dist:
      check = False
      fee = postfee(dist[add])
      for disc in sorted(discount):
          if dist[add] >= disc:
              check = True
              if fee>=discount[disc]:
                  result[add] = fee-discount[disc]
              else:
                  result[add] = 0
      if check == False:
          result[add] = fee
  return result
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  best = {}
  for center in dispatch_centers:
      fees = calculate_fee(senders, receivers, address, discount, dispatch_centers[center])
      best[center] = sum(fees.values())
  minn = min(best.values())
  result = []
  for fee in best:
      if best[fee] == minn:
          result.append(fee)
  result.sort()
  return [result[0],best[result[0]]]

xxx044xxxx: HW9
bytecount: {'code': 586, 'const': 162, 'code+const': 748}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  A = [] ; B = [] ; C = []
  for e in senders:
    if e in receivers:
      A += receivers[e]
  for i in range(len(A)-1):
    if A[i-1] != A[i] != A[i+1] :
      B.append(A[i])
  for e in A:
    C.append(address[e])
  C.sort()
  return C
def get_item_count(sending_addresses) :
  A = {}
  for e in sending_addresses:
    if e in A:
      A[e] += 1
    else:
      A[e] = 1
  return A
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  cal = {}
  for e in senders: 
    if e in receivers: 
      d = 0 
      for x in receivers[e]: 
        d += get_distance(address[x],dispatch_center_addr)
      if d <= 10:
        cost = d*2
      else:
        cost = 20 + (d-10)*3
      A = []
      for f in discount:
        if d >= f:
          A.append(f)
      d = 0
      if len(A) == 0:
          total = cost
      else:
          total = cost - discount[max(A)]
      if total < 0:
        total = 0
      cal[e] = total
    else:
      cal[e] = 0
  return cal
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  A = []
  location ={}
  for e in dispatch_centers:
    x = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    s = 0
    for f in x:
      s += x[f]
    A.append([s,e]) 
  A.sort()
  return A[0][::-1]

xxx033xxxx: HW9
bytecount: {'code': 562, 'const': 188, 'code+const': 750}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    a = []
    for e in senders:
        if e in receivers: 
            b = receivers[e]
            for h in b:
                a.append(address[h])
    return a
def get_item_count(sending_addresses) :
    vote = {}
    for e in sending_addresses:
        vote[e] = 0
    for e in sending_addresses:
        vote[e] += 1
    return vote
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
     b = {}
     for e in senders: 
         x = get_sending_addresses([e], receivers, address) 
         a = []
         for h in x: 
             y = get_distance(h, dispatch_center_addr)
             a.append(y) 
         c = sum(a)
         value = 0
         if c == 0:
             value = 0
         else: 
             if 1 <= c <= 10:
                 value += c*2
             else:
                 value += (c-10)*3+10*2
             check_key = []
             for f in discount:
                 if c >= f:
                     check_key.append(f) 
             if check_key != []:
                 maxx = check_key[-1]
                 value = value-discount[maxx]
             if value <= 0:
                value = 0
         b[e] = value
     return b
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    a = {}
    for e in dispatch_centers: 
        z = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        value = 0
        for g in z:
            value+= z[g]
        a[e] = value 
    b = [] 
    for e in a:
        b.append([a[e],e]) 
    ans= []
    b.sort()
    ans = b[0]
    ans = ans[::-1]
    return ans

xxx039xxxx: HW9
bytecount: {'code': 602, 'const': 148, 'code+const': 750}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  s = [] 
  a = [] 
  for e in receivers:
    if e in senders:
      for n in receivers[e]:
        s.append(n)
  for n in s:
    a.append(address[n])
  return a
def get_item_count(sending_addresses) :
  n = {}
  for e in sending_addresses:
    if e not in n:
        n[e] = 1
    elif e in n:
        n[e] += 1
  return n
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  t = {}
  for e in senders:
    n = get_sending_addresses(e, receivers, address)
    d = 0
    p = 0
    for i in n:
      d += get_distance(i,dispatch_center_addr)
    if d <= 10 :
        p = d*2
    elif d > 10:
        p = ((d-10)*3) + (10*2)
    k =[]
    for s in discount:
      k.append(s)
    k = k[::-1]
    for i in range(len(k)):
      if d >= k[i]:
        p = p - discount[k[i]]
        break
    if p < 0:
      p = 0
    t[e] = p  
  return t
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  l = {}
  k = []
  s = []
  r = []
  for e in dispatch_centers:
    d = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    t = 0
    for n in d:
      t += d[n]
    l[e] = t
    k.append(t)
  m = min(k)
  for e in l:
    if l[e] == m:
       s.append(e)
  s.sort()
  r.append(s[0])
  r.append(m)
  return r

xxx030xxxx: HW9
bytecount: {'code': 606, 'const': 146, 'code+const': 752}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ad = []
  for name in senders:
      if name in receivers:
          list_recive = receivers[name]
          for r_name in list_recive:
              if r_name in address:
                  ad.append(address[r_name])
  return ad
def get_item_count(sending_addresses) :
  out = {}
  for house in sending_addresses:
      out[house] = 0
  for house in sending_addresses:
      if house in out:
          out[house] += 1
  return out
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  out = {}
  for send in senders:
    s = get_sending_addresses([send], receivers, address)
    dist = 0; price = 0
    for rec in s:
        dist +=  get_distance(rec, dispatch_center_addr)
    if dist > 10:
        n_dist = dist - 10
        price = (10 * 2) + (n_dist * 3)
    else:
        price = dist * 2
    l = []
    for m in discount:
        if dist >= m:
            l.append(m)
    if l != []:
        count = max(l)
        price -= discount[count]
    if price < 0:
        price = 0
    out[send] = price
  return out
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  out = {}
  for loca in dispatch_centers:
      check = calculate_fee(senders, receivers, address, discount, dispatch_centers[loca])
      sum = 0
      for k in check:
        sum += check[k]
      out[loca] = sum
  all_price = []
  for m in out:
    all_price.append(out[m])
  check_loca = []; x = min(all_price)
  for i in range (len(all_price)):
    if all_price[i] == x:
        for k in out:
            if out[k] == all_price[i]:
                check_loca.append(k)
  check_loca.sort()
  end = [check_loca[0], out[check_loca[0]]] 
  return end

xxx217xxxx: HW9
bytecount: {'code': 600, 'const': 162, 'code+const': 762}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    l = []
    for sender in senders:
        if sender in receivers:
              list_of_receivers = receivers[sender]
              for receiver in list_of_receivers:
                  if receiver in address:
                      l.append(address[receiver])
    return l
def get_item_count(sending_addresses) :
    l = {}
    for addresses in sending_addresses:
        if addresses not in l:
            l[addresses] = 1
        else :
            l[addresses] += 1
    return l
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    l = []
    ans = {}
    for distance in discount:
        l.append([distance,discount[distance]])
    l.sort()
    for sender in senders:
        all_adre = get_sending_addresses([sender], receivers, address)
        adre_and_count = get_item_count(all_adre)
        total_distance = 0
        for adre in adre_and_count:
            total_distance += get_distance(adre, dispatch_center_addr)
        if total_distance <= 10:
            price = total_distance*2
        else:
            price = 20 + (total_distance-10)*3
        dis = 0
        for i in range(len(l)-1):
            if l[i][0] <= total_distance < l[i+1][0]:
                dis = l[i][1]
            elif l[i+1][0] <= total_distance:
                dis = l[i+1][1]
        final_price = price - dis
        if final_price < 0:
            final_price = 0
        ans[sender] = final_price
    return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    l = []
    for name in dispatch_centers:
        sum = 0
        all_price = calculate_fee(senders, receivers, address, discount, dispatch_centers[name])
        for namee in all_price:
            sum += all_price[namee]
        l.append([sum,name])
    l.sort()
    return [l[0][1],l[0][0]]

xxx201xxxx: HW9
bytecount: {'code': 590, 'const': 174, 'code+const': 764}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  gsa = []
  for i in senders :
      if i in receivers :
          for n in receivers[i] :
              gsa += [address[n]]
  return gsa
def get_item_count(sending_addresses) :
  gic = {}
  for n in sending_addresses :
      gic[n] = 0
  for n in sending_addresses :
      if n in gic :
          gic[n] += 1
  return gic
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  cf = {}
  for n in senders :
      cf[n] = 0
  for n in senders :
      m = get_sending_addresses([n], receivers, address)
      dis = 0
      for i in m :
          dis += get_distance(dispatch_center_addr, i)
      if dis <= 10 :
          cf[n] += 2*dis
      else :
          cf[n] += 10*2 + (dis-10)*3
      disc = 0
      for i in discount :
          if dis >= i :
              disc = discount[i]
      cf[n] -= disc    
  for i in cf :
      if cf[i] < 0 :
          cf[i] += cf[i]*(-1)
  return cf
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  fbl = []
  a = {}
  b = []
  for i in dispatch_centers :
      a[i] = 0
  for i in dispatch_centers :
      n = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
      for x in n :
          a[i] += n[x]
  for x in a:
    b += [[a[x],x]]
  n = sorted(b)
  fbl += n[0][::-1]
  return fbl

xxx020xxxx: HW9
bytecount: {'code': 592, 'const': 176, 'code+const': 768}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  add = []
  for e in senders:
      if e in receivers:
          name = receivers[e]
          for c in name:
              if c in address:
                  add.append(address[c])
  return add
def get_item_count(sending_addresses) :
  item = {}
  for e in sending_addresses:
      if e not in item:
            item[e] = 1
      else:
            item[e] += 1
  return item
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  price = {}
  l = []
  for k in discount:
    l.append([k,discount[k]])
  l.sort()
  for e in senders: 
      sum = 0
      if e in receivers:
          name = receivers[e]
          d = 0
          for c in name: 
              d += get_distance(address[c],dispatch_center_addr)
          if d<= 10:
              sum += d*2
          else:
              sum += 20 + ((d-10)*3)
          for i in range(len(l)):
              if i<len(l)-1:
                  if l[i][0]<=d and d<l[i+1][0]:
                      sum -= l[i][1]
              else:
                  if d>l[-1][0]:
                      sum -= l[-1][1]
      if sum<0: 
          sum = 0
      price[e] = sum
  return price
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  cen = []
  for key in dispatch_centers:
      sum = 0
      nprice = calculate_fee(senders, receivers, address, discount, dispatch_centers[key])
      for k in nprice:
          sum += nprice[k]
      cen.append([sum,key])
  cen.sort()
  return cen[0][::-1]

xxx038xxxx: HW9
bytecount: {'code': 578, 'const': 194, 'code+const': 772}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  x=[]
  for i in senders:
    if i in receivers:
      a=receivers[i]
      for j in a:
        b=address[j]
        x.append(b)
  return x
def get_item_count(sending_addresses) :
  d={}
  for i in sending_addresses:
    if i not in d:
      d[i]=1
    else:
      d[i]+=1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  e={}
  for i in senders:
    e[i]=0
  x=[]
  for i in discount:
    x.append(i)
  x.sort(reverse=True)
  for i in senders:
    if i in receivers:
      a=receivers[i]
      dist=0
      for j in a:
        l=address[j]
        dist+= get_distance(l,dispatch_center_addr)
      v=0
      if dist>10:
        v=(dist-10)*3+20
      else:
        v=dist*2
      for k in x:
        if dist >= k:
          v-=discount[k]
          break
      if v < 0:
        v=0
      e[i]+=v
  return e
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  x=[]
  for i in dispatch_centers:
    z=0
    y=calculate_fee(senders, receivers, address, discount,dispatch_centers[i]) 
    for j in y:
      z+=y[j]
    x.append([z,i])
  x.sort()
  min=x[0][0]
  a=[]
  for i in x:
    if i[0]==min:
      a.append([i[1],i[0]])
  a.sort()
  return a[0]

xxx042xxxx: HW9
bytecount: {'code': 610, 'const': 162, 'code+const': 772}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  x = []
  for c in senders:
    if c in receivers:
      for i in range(len(receivers[c])):
        if receivers[c][i] in address:
          x.append(address[receivers[c][i]])
    else:
      pass
  return x
def get_item_count(sending_addresses) :
  a = {}
  for ch in sending_addresses:
    if ch in a:
      a[ch]+=1
    else:
      a[ch] = 1
  return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  dis = {}
  check = []
  maxtomin = []
  for i in discount:
    maxtomin.append(i)
  maxtomin.sort()
  for e in senders:
    dis[e] = 0
    if e in receivers: 
      for x in receivers[e]:
        dis[e]+=get_distance(address[x], dispatch_center_addr)
  for e in dis:
    if dis[e] >= 10:
      fee[e] = (10*2) + (dis[e]-10)*3
    else:
      fee[e] = dis[e]*2
    for i in maxtomin[::-1]:
      if dis[e] >= i:
        fee[e] -= discount[i]
        break
    if fee[e] <= 0:
        fee[e] = 0 
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  price = []
  raka = {}
  for e in dispatch_centers:
    raka[e] = 0
    pay = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    for c in pay:
      raka[e]+=pay[c]
  for x in raka:
    price.append([raka[x],x])
  price.sort()
  value = price[0][::-1]
  return value

xxx121xxxx: HW9
bytecount: {'code': 628, 'const': 148, 'code+const': 776}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  z = []
  for i in senders:
    if i in receivers:
      s = receivers[i]
      for j in s:
        z.append(address[j])
  return z
def get_item_count(sending_addresses) :
  d = {}
  for i in sending_addresses:
    if i not in d:
      d[i] = 1
    elif i in d:
      d[i] = d[i] + 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  calculate_fees = {}
  discount2 = [] 
  for i in discount: 
      discount2.append(i)
  for i in senders:
      distance = 0
      addresses = get_sending_addresses([i], receivers, address)
      if addresses == []:
          calculate_fees[i] = 0
      elif addresses != []:
          for j in addresses: 
              distance = distance + get_distance(j, dispatch_center_addr)
          if distance <= 10:
              fee = distance*2      
          elif distance >= 10:
              fee = 10*2 + (distance-10)*3  
          for k in range(len(discount2)):
              maxx = discount2[-1-k]
              if distance >= maxx:
                  fee = fee - discount[maxx]
                  if fee < 0:
                      fee = 0
                  calculate_fees[i] = fee
                  break
          calculate_fees[i] = fee
  return calculate_fees
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  x = {} 
  z = [] 
  s = [] 
  findmin = []
  for i in dispatch_centers:
      y = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
      for j in y:
          s.append(y[j])
      x[i] = sum(s)
      s = []
  for i in x:
      findmin.append(x[i])
  f = min(findmin)
  for i in x:
      if x[i] == f:
          z.append(i)
  z.sort()
  m = []
  m.append(z[0])
  m.append(f)    
  return m

xxx020xxxx: HW9
bytecount: {'code': 598, 'const': 178, 'code+const': 776}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  f=[]
  for s in senders:
      if s in receivers:
          for k in receivers[s]:
              f.append(address[k])
  return f
def get_item_count(sending_addresses) :
  n={}
  for k in sending_addresses:
      n[k]=sending_addresses.count(k)
  return n
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  r1={s:0 for s in senders}
  for k in receivers:
      if k in r1:
          for s in receivers[k]:
              r1[k]+=get_distance(address[s],dispatch_center_addr)
  pr={k:2*v if v<10 else 3*(v-10)+20 for k,v in r1.items()}
  r2=list(discount.keys())
  r2.sort(reverse=True)
  for k,v in r1.items():
      for u in range(len(r2)):
          if v>=r2[u]:
              if pr[k]>discount[r2[u]]:
                  pr[k]-=discount[r2[u]]
              else:
                  pr[k]=0
              break
  return (pr)
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  fee={k:sum(calculate_fee(senders, receivers, address, discount, v).values()) for k,v in dispatch_centers.items()}
  ans=[i for i in fee if fee[i]==min(fee.values())]
  ans.sort()
  return [ans[0],fee[ans[0]]]

xxx033xxxx: HW9
bytecount: {'code': 628, 'const': 148, 'code+const': 776}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  who_received = []
  for name in senders :
    if name in receivers :
      who_received += receivers[name]
  receiver_adresses = []
  for receiver in who_received :
    if receiver in address :
      receiver_adresses += [address[receiver]]
  return receiver_adresses
def get_item_count(sending_addresses) :
  n_adresses = {}
  for adr in sending_addresses :
    if adr in n_adresses :
      n_adresses[adr] += 1
    else :
      n_adresses[adr] = 1
  return n_adresses
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  sender_fee = {}
  off = list(discount.keys())
  for name in senders :
    dis_key = []
    distance = 0
    destination = get_sending_addresses([name], receivers, address)
    if destination == [] :
      sender_fee[name] = 0
    else :
      for d in destination :
        distance += get_distance(d,dispatch_center_addr)
      if distance <= 10 :
        fee = distance*2
      else :
        fee = (10*2)+((distance-10)*3)
      for e in off :
          minus = distance - e
          if minus >= 0 :
              dis_key += [minus]
      if dis_key == [] :
          sender_fee[name] = fee
      else :
          mini = min(dis_key)
          i = dis_key.index(mini)
          b = fee-discount[off[i]]
          if b < 0 :
              b = 0
          sender_fee[name] = b
  return sender_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  fee = {}
  pathfee = []
  fees = []
  lowest_dict = {}
  lowest_start = []
  dcname = list(dispatch_centers.keys())
  for name in dcname :
    feeperpath = calculate_fee(senders, receivers, address, discount, dispatch_centers[name])
    feetotal = sum(list(feeperpath.values()))
    fees += [feetotal]
    pathfee += [[name,feetotal]]
  mini = (min(fees))
  for pf in pathfee :
    if mini == pf[1] :
      lowest_dict[pf[0]] = pf[1]
      lowest_start += [pf[0]]
  first_lowest = sorted(lowest_start)[0]
  out = [first_lowest,lowest_dict[first_lowest]]
  return out

xxx019xxxx: HW9
bytecount: {'code': 618, 'const': 162, 'code+const': 780}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    receive_n = []
    add = []
    a = []
    for name in senders:
      if name in receivers:
          a = receivers[name]
          for ch in a:
            receive_n.append(ch)
    for name in receive_n:
      if name in address:
          add.append(address[name])
    return add
def get_item_count(sending_addresses) :
    add ={}
    for n in sending_addresses:
        if n in add:
            add[n] += 1
        else:
            add[n] = 1
    return add
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    dis = []
    for n in discount:
                dis.append(n)
    dis.sort()
    out = {}
    for name in senders:
        tot = 0
        minus = 0
        s = 0
        sending = get_sending_addresses([name], receivers, address)
        for add in sending:
            s += get_distance(add,dispatch_center_addr)
        if s < 10:
            tot += 2*s
        if s >= 10:
            tot += 20 + (s-10)*3
        for n in range(len(dis)-1):
            if s >= dis[n] and s < dis[n+1]:
                minus = discount[dis[n]]
            elif s >= dis[len(dis)-1]:
                minus = discount[dis[len(dis)-1]]
        tot -= minus
        if tot < 0:
            tot = 0
        out[name] = tot
    return out
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    min = []
    for ch in dispatch_centers:
        tot = 0
        a = calculate_fee(senders, receivers, address, discount, dispatch_centers[ch])
        for n in a:
            tot += a[n]
        min.append([tot,ch])
    min.sort()
    return [min[0][1],min[0][0]]

xxx023xxxx: HW9
bytecount: {'code': 622, 'const': 160, 'code+const': 782}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ad_send_list = []
  receive = []
  for send in senders:
      if send in receivers:
          for e in receivers[send]:
              ad_send_list.append(address[e])
  return ad_send_list
def get_item_count(sending_addresses) :
  ad={}
  for address in sending_addresses :
      ad[address] = 0
  for check_address in sending_addresses :
      if check_address in ad:
        ad[check_address] += 1
      else:
        ad[check_address] = 1 
  return ad
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  pay={}
  distance_dic = {}
  minus = 0
  for send in senders:
        send_address = get_sending_addresses([send], receivers, address)
        for each_add in send_address :
            if send in distance_dic:
                distance_dic[send] += get_distance(each_add,dispatch_center_addr)
            else:
                distance_dic[send] = get_distance(each_add,dispatch_center_addr)
        pay[send] = 0
  for d in distance_dic:
      if distance_dic[d] <= 10:
          pay[d] = 2*distance_dic[d]
      else:
          pay[d] = 20 + 3*(distance_dic[d] - 10)
      for i in range(distance_dic[d]+1):
          if i in discount :
              minus = discount[i]
      pay[d] -= minus
      if pay[d] < 0 :
          pay[d] = 0
  return pay
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  tot_pay={}
  for city in dispatch_centers:
     tot_pay[city] = 0
     for pay in calculate_fee(senders, receivers, address, discount, dispatch_centers[city]).values():
           tot_pay[city] += pay
  pay_list = []
  min_city = []
  for e in tot_pay.values():
      pay_list.append(e)
  for m in tot_pay:
      if tot_pay[m] == min(pay_list):
          min_city.append(m)
          min_city.sort()
  return [min_city[0] , min(pay_list)]

xxx028xxxx: HW9
bytecount: {'code': 622, 'const': 162, 'code+const': 784}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  b=[]
  c=[]
  for i in senders:
      if i in receivers:
          a=receivers[i]
          for k in a:
                  b.append(k)
  for g in b:
      if g in address:
          c.append(address[g])
  return c
def get_item_count(sending_addresses) :
  a={}
  for i in sending_addresses:
      if i not in a:
          a[i]=1
      else:
          a[i]+=1
  return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  q={}
  g=[]
  for h in discount:
      g.append(h)
  for i in senders:
      h=0
      m=0
      a=get_sending_addresses([i], receivers, address)
      for k in a:
          h+=get_distance(k,dispatch_center_addr)
      if h<=10:
          m=2*h
      else:
          m=20+(h-10)*3
      g.append(h)
      g.sort()
      g=g[::-1]
      p=g.index(h)
      if p==len(g)-1:
          pass
      else:
          m-=discount[g[p+1]]
      if m<0:
          m=0
          q[i]=m
      else:
          q[i]=m
      g.remove(h)
  return q
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  p=[]
  for i in dispatch_centers:
      m=0
      a=calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
      for k in a:
          m+=a[k]
      p.append([m,i])
  p.sort()
  b=[]
  mi=p[0][0]
  for x,y in p:
      if x==mi:
          b.append([y,x])
      else:
          break
  b.sort()
  return b[0]

xxx041xxxx: HW9
bytecount: {'code': 626, 'const': 162, 'code+const': 788}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    name_rec = []
    location = []
    for e in senders:
        if e in receivers:
            x = receivers[e]
            for n in x:
                name_rec.append(n)
    for m in name_rec:
        location.append(address[m])
    return location
def get_item_count(sending_addresses) :
    a = {}
    for e in sending_addresses:
        if e not in a:
            a[e] = 1
        else:
            a[e] += 1
    return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    t = {}
    dc = []
    s = 0
    for e in senders:
        if e in receivers:
            b = receivers[e]
            for p in b:
                s += get_distance(address[p], dispatch_center_addr)
            if s < 10:
                price = s*2
            else:
                price = (s-10)*3+(10*2)
            for q in discount:
                if s >= q:
                    dc.append(discount[q])
            if dc == []:
                dc.append(0)
            cost = price-dc[-1]
            if cost <= 0:
                cost = 0
            t[e] = cost
        else:
            t[e] = 0
        s = 0
    return t
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    x = [] 
    y = []
    r = []
    s = {}
    last = []
    for e in dispatch_centers:
        x.append([e,calculate_fee(senders, receivers, address, discount, dispatch_centers[e])])
    for n in x:
        for m in n[1]:
            y.append(n[1][m])
        t = sum(y)
        s[n[0]] = t
        r.append(t)
        y = []
    p = min(r)
    for k in s:
        if s[k] == p:
            last.append(k)
    last.sort()
    ans = [last[0],s[last[0]]]
    return ans

xxx042xxxx: HW9
bytecount: {'code': 606, 'const': 184, 'code+const': 790}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  addresses = []
  for sender in senders:
      if sender in receivers:
          for receiver in receivers[sender]:
              if receiver in address:
                  addresses.append(address[receiver])
  return addresses
def get_item_count(sending_addresses) :
  item_count = {}
  for address in sending_addresses:
      if address not in item_count:
          item_count[address] = 1
      else:
          item_count[address] += 1
  return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for sender in senders:
      if sender in receivers:
          total_d = 0
          total_fee = 0
          for receiver in receivers[sender]:
              if receiver in address:
                  total_d += get_distance(address[receiver], dispatch_center_addr)
          if 0 <= total_d <= 10: 
              total_fee += total_d*2
          else:
              total_fee += ( 10*2 + (total_d - 10)*3 )
          postal_d,postal_dc = 0,0
          for distance_rate in discount:
              if postal_d <= distance_rate <= total_d:
                  postal_d,postal_dc = distance_rate,discount[distance_rate]
          deducted_total_fee = total_fee - postal_dc
          if deducted_total_fee >= 0:
              fee[sender] = deducted_total_fee
          else:
              fee[sender] = 0
      else:
          fee[sender] = 0
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  list_dpctwithcost = []
  for dispatch_center in dispatch_centers:
      dispatch_center_addr = dispatch_centers[dispatch_center]
      cost = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
      total_cost = 0
      for sender in cost:
          total_cost += cost[sender]
      list_dpctwithcost.append( [dispatch_center, total_cost] )
  least_dpctwithcost = list_dpctwithcost[0]
  least_cost = least_dpctwithcost[1]
  for dpct_withcost in list_dpctwithcost:
      if dpct_withcost[1] <= least_cost:
          least_dpctwithcost = dpct_withcost
          least_cost = least_dpctwithcost[1]
  least_dpcts = []
  for dpct_withcost in list_dpctwithcost:
      if dpct_withcost[1] == least_cost:
          least_dpcts.append(dpct_withcost)
  least_dpcts.sort()
  return least_dpcts[0]

xxx205xxxx: HW9
bytecount: {'code': 614, 'const': 176, 'code+const': 790}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  keep=[]
  ans=[]
  for i in range(len(senders)):
    if senders[i] in receivers:
      keep.append(receivers[senders[i]])
  for i in range(len(keep)):
      for j in range(len(keep[i])):
          ans.append(address[keep[i][j]])
  return ans
def get_item_count(sending_addresses) :
  ans={}
  for i in sending_addresses:
      if i not in ans:
          ans[i]=1
      else:
          ans[i]+=1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  ans={}
  for j in range(len(senders)):
    value=0
    r = get_sending_addresses([senders[j]], receivers, address) 
    km = 0
    for i in range(len(r)):
        km += get_distance(r[i],dispatch_center_addr)
    pay = 0
    if km <= 10:
        pay = km*2
    elif km > 10:
        pay = 10*2 + (km-10)*3
    use = 0
    keep=[]
    for e in sorted(discount):
        keep.append(e)
    for k in range(len(keep)-1,-1,-1):
        if km >= keep[k]:
            use=discount[keep[k]]
            break
    value = pay-use 
    if value < 0:
        value=0
    ans[senders[j]]=value
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  keep = []
  for i in dispatch_centers:
      dispatch_center_addr = dispatch_centers[i]
      fee = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
      sum = 0
      for j in fee:
          sum += fee[j]
      keep.append([sum,i,sum])
  keep.sort()
  return keep[0][1:]

xxx216xxxx: HW9
bytecount: {'code': 656, 'const': 134, 'code+const': 790}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  who = [] ; address2 = []
  for e in senders:
      if e in receivers:
          for x in receivers[e]:
              who.append(x)
  for e in who :
      if e in address:
          address2.append(address[e])
  return address2
def get_item_count(sending_addresses) :
  d = {}
  for e in sending_addresses:
      if e in d:
          d[e] += 1
      else:
          d[e] = 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d ={}
  for e in senders:
      who = [] ; distance = 0 ; address2 = []
      if e in receivers:
          for x in receivers[e]:
              who.append(x)
          for f in who :
              if f in address:
                  address2.append(address[f])
          for g in range(len(address2)):
              distance += get_distance(dispatch_center_addr, address2[g])
          before = 0
          if distance >= 10:
              before += 2*10
              distance2 = distance - 10
              before += 3*distance2
          else:
              before += distance*2
          k = 0
          for h in discount:
              if h > distance:
                  break
              k = h
          cash = before
          if k > 0:
              cash = before - discount[k]
          if cash < 0:
              cash = 0
      else:
          cash = 0
      d[e] = cash
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  d = {} ; mintotal = []
  for a in dispatch_centers:
      cash = calculate_fee(senders, receivers, address, discount, dispatch_centers[a])
      total = 0
      for b in cash:
          total += cash[b]
      mintotal.append(total)
      if total in d:
          d[total].append(a)
      else:
          d[total] = [a]
  l = []
  mintotal2 = min(mintotal)
  where = d[mintotal2]
  where.sort()
  l.append(where[0]) ; l.append(mintotal2)
  return l

xxx020xxxx: HW9
bytecount: {'code': 586, 'const': 206, 'code+const': 792}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  houseNum = []
  for x in senders:
      if x in receivers: 
        for y in receivers[x]:
            houseNum.append(address[y]) 
  return houseNum
def get_item_count(sending_addresses) :
  address2item = {}
  for e in sending_addresses:
      if e not in address2item:
          address2item[e] = 1
      else: address2item[e] += 1
  return address2item
def fee_rate(d):
    if d >= 10:
        fee = 10*2 + (d-10)*3
    else: fee = d*2
    return fee
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  sender2fee = {}
  for x in senders:
    totalDistance, sender2fee[x] = 0, 0
    houseNum = []
    if x in receivers: 
        for y in receivers[x]:
            houseNum.append(address[y])
    if houseNum != []:
        for y in houseNum:
            totalDistance += get_distance(y, dispatch_center_addr)
        sender2fee[x] += fee_rate(totalDistance)
    discountList = sorted(discount)[::-1]
    for e in discountList:
        if e <= totalDistance:
            sender2fee[x] -= discount[e]
            if sender2fee[x] < 0:
                sender2fee[x] = 0
            break
  return sender2fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  allLocation = []
  best = [] 
  for k1 in dispatch_centers:
      totalFee = 0
      sender2fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[k1])
      for k2 in sender2fee:
          totalFee += sender2fee[k2]
      allLocation.append([totalFee,k1])
  minFee = min(allLocation)
  for e in allLocation:
      if e[0] == minFee[0]:
          best.append([e[1],e[0]])
  best.sort()
  return best[0]

xxx027xxxx: HW9
bytecount: {'code': 632, 'const': 162, 'code+const': 794}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    x = []
    for e in senders:
        if e in receivers:
            for i in range(len(receivers[e])):
                x.append(receivers[e][i])
    a = []
    for e in x:
        a.append(address[e])
    return a
def get_item_count(sending_addresses) :
    c = {}
    for e in sending_addresses:
        if e in c:
            c[e] += 1
        else:
            c[e] = 1
    return c
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    a = {}
    for e in senders:
        a[e]=0
    for e in senders:
        x = []
        if e in receivers:
            for i in range(len(receivers[e])):
                x.append(receivers[e][i])
            d = 0
            for i in x:
                d+=get_distance(address[i],dispatch_center_addr)
            if d<=10:
                t = d*2
            else:
                t = 20+(d-10)*3
            if d in discount:
                dis = discount[d]
            else:
                dc = [d]
                for c in discount:
                    dc.append(c)
                dc.sort()
                i = dc.index(d)
                if i!=0:
                    dis = discount[dc[i-1]]
                else:
                    dis = 0
            if dis >= t:
                t = 0
            else:
                t -= dis
            a[e] += t
    return a
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    a = []
    for e in dispatch_centers:
        x = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        t = 0
        for d in x:
            t+=x[d]
        a.append([t,e])
    a.sort()
    r = [a[0][1],a[0][0]]
    return r

xxx215xxxx: HW9
bytecount: {'code': 608, 'const': 186, 'code+const': 794}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address):
    addr_out = list()
    for sender in senders:
        if sender in receivers:
            for receiver in receivers[sender]:
                addr_out.append(address[receiver])
    return addr_out
def get_item_count(sending_addresses):
    addresses_count = dict()
    for address in sending_addresses:
        if address not in addresses_count:
            addresses_count[address] = 0
        addresses_count[address] += 1
    return addresses_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr):
    warehouse_address = dispatch_center_addr
    u_discount = discount
    u_discount.setdefault(0, 0)
    v_discount = sorted(list(u_discount.keys()))
    senders_attr = {k: 0 for k in senders}
    av_dest = [
        [sender, receiver] for sender in senders if sender in receivers
        for receiver in receivers[sender]
    ]
    for sender, receiver in av_dest:
        senders_attr[sender] += get_distance(address[receiver], warehouse_address)
    for user, distance in senders_attr.items():
        dist_calc = sorted([[distance - x, x] for x in v_discount if distance - x >= 0])
        flat_rate = (2 * distance) if distance <= 10 else (20 + 3 * (distance - 10))
        dc = discount[min(dist_calc)[1]] if dist_calc else 0
        senders_attr[user] = flat_rate - dc if flat_rate >= dc else 0
    return senders_attr
def find_best_location(senders, receivers, address, discount, dispatch_centers):
    dispatch_all = dict()
    for dispatch_location, dispatch_address in dispatch_centers.items():
        dispatch_all[dispatch_location] = sum(
            calculate_fee(senders, receivers, address, discount, dispatch_address).values()
        )
    return min([[v, k] for k, v in dispatch_all.items()])[::-1]

xxx218xxxx: HW9
bytecount: {'code': 632, 'const': 162, 'code+const': 794}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  sending_addresses = []
  for sender in senders :
    if sender in receivers :
      for receiver in receivers[sender] :
        sending_addresses.append(address[receiver])
  return sending_addresses
def get_item_count(sending_addresses) :
  item_count = {}
  for address in sending_addresses :
    if address in item_count :
      item_count[address] += 1
    else :
      item_count[address] = 1
  return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  result = {}
  key = []
  for i in discount:
    key.append(i)
    key.sort()
  key_backwards = key[::-1]
  each_dis = {}
  for i in senders:
      result[i] = 0
      if i in receivers:
          for j in range(len(receivers[i])):
              ad = receivers[i][j]
              if i in each_dis:
                  each_dis[i] += get_distance(address[ad],dispatch_center_addr)
              else:
                  each_dis[i] = get_distance(address[ad],dispatch_center_addr)
          if each_dis[i] <= 10:
              result[i] += each_dis[i]*2
          else:
              result[i] += 10*2 + (each_dis[i]-10)*3         
          for m in range(len(key_backwards)):
              if key_backwards[m] <= each_dis[i]:
                  if discount[key_backwards[m]] <= result[i]:
                      result[i] -= discount[key_backwards[m]]
                  else:
                      result[i] = 0
                  break
  return result
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  fbl = []
  for dip in dispatch_centers:
      charge = 0
      result = calculate_fee(senders, receivers, address, discount,dispatch_centers[dip])
      for i in result:
          charge += result[i]
      fbl.append([charge,dip])
  fbl.sort()
  final = fbl[0]
  reverse = final[::-1]
  return reverse

xxx027xxxx: HW9
bytecount: {'code': 536, 'const': 260, 'code+const': 796}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  result = []
  for sender in senders:
    if sender in receivers:
      for receiver in receivers[sender]:
        if receiver in address:
          result.append(address[receiver])
  return result
def get_item_count(sending_addresses) :
  result = dict.fromkeys(sending_addresses, 0)
  for item in sending_addresses:
    result[item] += 1
  return result
def get_cost(costs):
  if len(costs) == 0:
    s = 0
  else:
    s = sum(costs)
  if s <= 10:
    return 2 * s
  return 20 + 3 * (s - 10)
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  result = {}
  for sender in senders:
    result[sender] = []
    if sender in receivers:
      for receiver in receivers[sender]:
        if receiver in address:
          result[sender].append(get_distance(address[receiver], dispatch_center_addr))
  return {sender: max(get_cost(cost) - (0 if len(discount) == 0 else discount[max(discount, key = lambda key: 0 if key > (0 if len(cost) == 0 else max(cost)) else key)]), 0) for sender, cost in result.items()}
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  result = []
  for dispatch_center, dispatch_center_addr in dispatch_centers.items():
    cost = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
    result.append([dispatch_center, sum(cost.values())])
  return min(result, key = lambda center: center[::-1])

xxx019xxxx: HW9
bytecount: {'code': 636, 'const': 162, 'code+const': 798}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  x = []
  ans = []
  for i in senders:
      if i in receivers:
          for j in receivers[i]:
              x.append(j)
  for k in x:
      ans.append(address[k])
  return ans
def get_item_count(sending_addresses) :
  dict1 = {}
  for i in sending_addresses:
      if i not in dict1:
          dict1[i] = 1
      elif i in dict1:
          dict1[i] = dict1[i] + 1
  return dict1
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    endpoint = {}
    for i  in senders:
        endpoint[i] = get_sending_addresses([i], receivers, address)
    tot = []
    d = 0
    fee2 = []
    ans = {}
    fee = 0
    y = 0
    for i in endpoint:
        for j in endpoint[i]:
            d = d + get_distance(j,dispatch_center_addr)
        tot.append(d)
        d = 0
    for distance in tot:
        if distance >= 10:
            fee = 20 + (distance-10)*3
        else:
            fee = distance * 2
        c = 0
        for j in discount:
            if c == 0:
                if distance >= j:
                    y = discount[j]
                    c = 1
                else:
                    break
                c = 1
            else:
                if distance >= j:
                    y = discount[j]
        fee = fee - y
        if fee < 0:
            fee = 0
        fee2.append(fee)
    for i in range (len(senders)):
        ans[senders[i]] = fee2[i]   
    return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans = []
  for i in dispatch_centers:
      dict1 = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
      c = 0
      for j in dict1:
          c = c + dict1[j]
      ans.append([c,i])
      c = 0
  ans.sort()
  ans2 = [ans[0][1],ans[0][0]]
  return ans2

xxx041xxxx: HW9
bytecount: {'code': 678, 'const': 120, 'code+const': 798}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    rec = []
    for s in senders:
        if s in receivers:
            for e in range(len(receivers[s])):
                rec.append(receivers[s][e])   
    add = []
    for i in rec:
        if i in address:
            add.append(address[i])
    return add
def get_item_count(sending_addresses) :
    quan = {}
    for e in sending_addresses:
        if e not in quan:
            quan[e] = 1
        else: quan[e] += 1
    return quan
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    paylist = {}
    for s in senders:
        ra = []
        if s in receivers:
            for e in range(len(receivers[s])):
                ra.append(receivers[s][e])
        else: paylist[s] = 0
        add = []
        for i in ra:
            if i in address:
                add.append(address[i])
        ttdist = 0
        for a in range(len(add)):
            dist = get_distance(add[a], dispatch_center_addr)
            ttdist += dist
        pay = 0
        if ttdist <= 10:
            pay += ttdist*2
        else:
            pay += (ttdist*3)-10
        disc = 0
        for dd in discount:
            if ttdist >= dd:
                disc = discount[dd]
        ttpay = pay - disc
        if ttpay < 0:
            ttpay = 0
        paylist[s] = ttpay
    return paylist
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    diff = 0
    center = []
    for cen in dispatch_centers:
        fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[cen])
        pay = 0
        for key in fee:
            pay += fee[key]
        if center == []:
            diff = pay
            center.append(cen)
        elif pay < diff:
            diff = pay
            center = []
            center.append(cen)
        elif pay == diff:
            center.append(cen)
    center.sort()
    select = []
    select.append(center[0])
    select.append(diff)
    return select

xxx244xxxx: HW9
bytecount: {'code': 568, 'const': 232, 'code+const': 800}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  r = [i for s in senders if s in receivers for i in receivers[s]]
  return [address[e] for e in r if e in address]
def get_item_count(sending_addresses):
  item = {}
  for a in sending_addresses:
    if a not in item:
      item[a] = 1
    else:
      item[a] += 1
  return item
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  sending_address = {s:get_sending_addresses([s],receivers,address) for s in senders}
  sender_fee = {}
  for e in sending_address:
    distance = 0
    for a in sending_address[e]:
      distance += get_distance(a,dispatch_center_addr)
    fee = (10*2) + ((distance-10)*3) if distance > 10 else distance*2
    dc = max([d for d in discount if d <= distance], default = 0)
    if dc in discount:
      sender_fee[e] = fee - discount[dc] if fee - discount[dc] >=0 else 0
    else:
      sender_fee[e] = fee
  return sender_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  location = []
  for d in dispatch_centers:
    sending_fee = calculate_fee(senders, receivers, address, discount , dispatch_centers[d])
    total_fee = 0
    for f in sending_fee:
      total_fee += sending_fee[f]
    location.append([d, total_fee])
  best_location = sorted(location, key=lambda l:(l[1],l[0]))
  return best_location[0]

xxx019xxxx: HW9
bytecount: {'code': 610, 'const': 190, 'code+const': 800}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  l =[]
  for e in senders:
    if e in receivers:
      for c in receivers[e]:
        if c in address: l.append(address[c])
  return l
def get_item_count(sending_addresses) :
  d = {}
  for e in sending_addresses:
    if e not in d:
      d[e] = sending_addresses.count(e)
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  for e in senders:
    if e in receivers:
      dis = 0
      for c in receivers[e]:
        dis += get_distance(address[c], dispatch_center_addr)
      if dis >= 10: p = (dis-10)*3 + 20
      else: p = dis*2
      md = 0
      for m in discount:
        if md<m<=dis:md = m
      if md in discount:
          if discount[md] < p:p -= discount[md]
          else:p=0
      d[e] = p
    else:
      d[e] = 0
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  l = []
  for k in dispatch_centers:
    pt = 0
    for e in senders:
      if e in receivers:
        dis = 0
        for c in receivers[e]:
          dis += get_distance(address[c], dispatch_centers[k])
        if dis >= 10: p = (dis-10)*3 + 20
        else: p = dis*2
        md = -1
        for m in discount:
          if md<m<=dis:md = m
        if md in discount:
          if discount[md] < p:p -= discount[md]
          else:p=0
        pt += p
    l.append([pt,k])
  l.sort()
  return l[0][::-1]

xxx038xxxx: HW9
bytecount: {'code': 602, 'const': 202, 'code+const': 804}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  return [address[e] for i in senders if i in receivers for e in receivers[i] if e in address]
def get_item_count(sending_addresses) :
  sd = dict()
  for i in sending_addresses:
    if i not in sd: sd[i] = 1
    else: sd[i] += 1
  return sd
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  c = {}
  for i in senders:
    send = get_sending_addresses([i], receivers, address)
    try:
      km = sum([get_distance(dispatch_center_addr, i) for i in send])
      dis = [e for e in sorted(discount) if km >= e]
      if len(dis) == 0: dis = 0
      else: dis = discount[dis[-1]]
      if km <= 10:
        p = km*2 - dis
        if p < 0: c[i] = 0
        else: c[i] = p
      else:
        p = (10*2) + ((km-10)*3) - dis
        if p < 0: c[i] = 0
        else: c[i] = p
    except:
      c[i] = 0
  return c
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  v = sorted([[-1 * sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]).values()), i] for i in dispatch_centers])
  return [[i[1], i[0] * -1]for i in v if i[0] == max(v)[0]][0]

xxx203xxxx: HW9
bytecount: {'code': 572, 'const': 234, 'code+const': 806}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  sent = []
  for i in senders:
    if i in receivers:
      for r in receivers[i]:
        sent.append(address[r])
  return sent
def get_item_count(sending_addresses) :
  d = {}
  for i in sending_addresses:
    if not i in d:
      d[i] = 1
    else:
      d[i] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  for i in senders:
    d[i] = 0
    ads = get_sending_addresses([i], receivers, address)
    dist = 0
    for a in ads:
      dist += get_distance(a,dispatch_center_addr)
    cost = 0
    if dist <=10:
      cost += dist*2
    else:
      cost += 10*2 + (dist-10)*3
    disc = []
    for e in discount:
      disc.append(e)
    disc = sorted(disc)
    disc2 = []
    for h in disc[-1::-1]:
        disc2.append(h)
    for s in disc2:
      if dist >= s:
        cost -= discount[s]
        break
    if cost < 0 :
      cost = 0
    d[i] += cost
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  done = ['ที่ตั้ง',1000000000000000]
  for i in dispatch_centers:
    dispatch_center_addr = dispatch_centers[i]
    d = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
    fee = 0
    for name in d:
      fee += d[name]
    if fee <  done[1]:
      done[0] = i
      done[1] = fee
    elif fee == done[1]:
      if done[0] > i:
        done[0] = i
        done[1] = fee
  return done

xxx035xxxx: HW9
bytecount: {'code': 662, 'const': 148, 'code+const': 810}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  a = []
  for e in senders:
      if e in receivers:
          for u in receivers[e]:
              a.append(address[u])
  return a
def get_item_count(sending_addresses) :
  listt = {}
  for i in sending_addresses:
      if i in listt:
          listt[i] += 1
      else:
          listt[i] = 1
  return listt
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  add = {}
  for e in senders:
      add[e] = get_sending_addresses([e], receivers, address)
  listt = {}
  for u in add:
      for a in add[u]:
          if u in listt:
              listt[u] += get_distance(dispatch_center_addr, a)
          else:
               listt[u] = get_distance(dispatch_center_addr, a)
      if add[u] == []:
          listt[u] = 0
  list_cost = {}
  a = 0
  for i in listt:
      if listt[i] <= 10:
          list_cost[i] = listt[i]*2
      else:
          list_cost[i] = 20 + (listt[i]-10)*3
      for k in discount:
          if listt[i] >= k:
              a = discount[k]
      list_cost[i] = list_cost[i] - a
      if list_cost[i] < 0:
          list_cost[i] = 0
  return list_cost
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  cost = {}
  for u in dispatch_centers:
      cf = calculate_fee(senders, receivers, address, discount, dispatch_centers[u])
      total = 0
      for i in cf:
          total += cf[i]
      cost[u] = total
  listt = []
  for k in cost:
      listt.append([cost[k],k])
  listt.sort()
  output = []
  for t in range(len(listt)):
      if listt[t][0] == listt[0][0]:
          output.append([listt[t][1],listt[t][0]])
  out = output[0]
  return out

xxx026xxxx: HW9
bytecount: {'code': 650, 'const': 162, 'code+const': 812}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  destination = []
  for n in senders :
      if n in receivers :
          destination += receivers[n]
  result = []
  for n in destination :
        result.append(address[n])
  return result
def get_item_count(sending_addresses) :
  result = {}
  for n in sending_addresses :
      if n not in result :
          result[n] = 1
      else : result[n] += 1
  return result
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  all_houses = {}
  for n in senders :
      ppl = []
      if n in receivers :
          for u in receivers[n] :
              ppl.append(address[u])
              distance = 0
              for t in ppl :
                  distance += get_distance(dispatch_center_addr,t)
      all_houses[n] = ppl 
  all_distances = {} ; all_costs = {}
  for n in all_houses :
      distance = 0
      for k in all_houses[n] :
          distance += get_distance(dispatch_center_addr,k)
      all_distances[n] = distance 
      if distance > 10 :
          costs = (distance-10)*3 + 10*2
      else : costs = distance*2
      all_costs[n] = costs 
  for n in all_distances : 
      result = {}
      if all_distances[n] != 0 :
          k = 0
          for i in range(all_distances[n]+1) :
              if all_distances[n] - k not in discount :
                  k += 1
              else :
                  all_costs[n] -= discount[all_distances[n] - k]
                  break
  for e in all_costs :
      if all_costs[e] < 0 :
          all_costs[e] = 0
  return all_costs
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  result = []
  for n in dispatch_centers :
      s = calculate_fee(senders, receivers, address, discount, dispatch_centers[n])
      distance = 0
      for y in s :
          distance += s[y]
      result.append([distance,n])
  result.sort()
  return result[0][::-1]

xxx207xxxx: HW9
bytecount: {'code': 664, 'const': 148, 'code+const': 812}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  liss = []
  if type(senders) == list:
    for k in senders:
      if k in receivers.keys():
        for i in receivers[k]:
          liss.append(address[i])
  elif type(senders) == str:
    if senders in receivers.keys():
        for i in receivers[senders]:
          liss.append(address[i])
  return liss
def get_item_count(sending_addresses) :
  di = {}
  for l in sending_addresses:
    if l in di:
      di[l] +=1
    else:
      di[l] = 1
  return di
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  di = {}
  for k in senders:
    li = get_sending_addresses(k, receivers, address)
    if li == []:
      di[k] = 0
    else:
      kilo = 0
      price = 0
      rod = 0
      pay = 0
      for l in li:
        kilo += get_distance(l,dispatch_center_addr)
      if kilo > 10 :
        price = 10*2+(kilo-10)*3
      else:
        price = kilo*2
      for s in discount.keys():
        if kilo >= s:
          rod = discount[s]
        else:
          break
      if (price - rod) >= 0:
        pay = price - rod
      else:
        pay = 0
      di[k] = pay
  return di
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  lowp = 0
  data = []
  lot = []
  for c in dispatch_centers:
    p = 0
    r = calculate_fee(senders, receivers, address, discount, dispatch_centers[c])
    for i in r.values():
      p+=i
    data.append([c,p])
  u = 0
  for i in data:
    if u == 0:
      lowp = i[1]
    else:
      if lowp >= i[1]:
        lowp = i[1]
    u += 1
  for d in data:
    if lowp == d[1]:
      lot.append(d)
  if len(lot) > 1:
    return (sorted(lot))[0]
  else:
    return lot[0]

xxx026xxxx: HW9
bytecount: {'code': 640, 'const': 176, 'code+const': 816}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  send_address = []
  for i in senders:
    for r in receivers.get(i, []):
      send_address.append(address[r])
  return send_address
def get_item_count(sending_addresses) :
  items = {}
  for i in sending_addresses:
    if i not in items:
      items[i] = 1
    else:
      items[i] += 1
  return items
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  dis = {}
  fee = {}
  n_discount = sorted(discount.items())[::-1]
  for s in senders:
    for a in get_sending_addresses([s], receivers, address):
      if s in dis:
        dis[s] += get_distance(a, dispatch_center_addr)
      else:
        dis[s] = get_distance(a, dispatch_center_addr)
    if s in dis:
      fee[s] = 0
      if dis[s] > 10:
        fee[s] += (dis[s]-10)*3
        fee[s] += 10*2
      else:
        fee[s] += dis[s]*2
      i = 0
      disc = 0
      while i < len(n_discount):
        n = n_discount[i][0]
        if n <= dis[s]:
          disc = discount[n]
          break
        i += 1
      fee[s] -= disc
      if fee[s] < 0:
        fee[s] = 0
  for s in senders:
    if s not in fee:
      fee[s] = 0
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  s_dispatch_centers = sorted(dispatch_centers.items())
  total = []
  for lo,adr in s_dispatch_centers:
    cost = 0
    fee = calculate_fee(senders, receivers, address, discount, adr)
    for i in fee:
      cost += fee[i]
    total.append([cost, lo])
  total.sort()
  return total[0][::-1]

xxx212xxxx: HW9
bytecount: {'code': 640, 'const': 176, 'code+const': 816}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  send = []
  for e in senders :
      if e in receivers :
          for i in range(len(receivers[e])) :
              send.append(address[receivers[e][i]])
  return send
def get_item_count(sending_addresses) :
  count = {}
  for e in sending_addresses :
    if e not in count :
        count[e] = 1
    elif e in count :
        count[e] += 1
  return count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  count_pay = 0
  dist_sum = 0
  add = []
  senders_pay = {}
  discount_list = []
  for e in discount :
    discount_list.append([e,discount[e]])
  discount_list.sort()
  discount_list = discount_list[::-1]
  for e in senders : 
    if e in receivers :
      for i in range(len(receivers[e])) :
        add.append(address[receivers[e][i]])
      for j in range(len(add)) :
        dist_sum += get_distance(add[j], dispatch_center_addr)
      if dist_sum <= 10 :
        count_pay = dist_sum*2
      else :
        count_pay = 10*2 + (dist_sum-10)*3
      for k in range(len(discount_list)) :
        if dist_sum >= discount_list[k][0] :
            count_pay -= discount_list[k][1]
            break
      if count_pay <= 0 :
        senders_pay[e] = 0
      else :
        senders_pay[e] = count_pay
      count_pay = 0
      dist_sum = 0
      add = []
    else :
      senders_pay[e] = 0
  return senders_pay
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  center_pay = []
  sum = 0
  for e in dispatch_centers :
    for d in calculate_fee(senders, receivers, address, discount, dispatch_centers[e]) :
      sum += calculate_fee(senders, receivers, address, discount, dispatch_centers[e])[d]
    center_pay.append([sum,e])
    sum = 0
  center_pay.sort()
  center_pay_select = center_pay[0][::-1]
  return center_pay_select

xxx023xxxx: HW9
bytecount: {'code': 630, 'const': 188, 'code+const': 818}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans = []
  for i in range(len(senders)):
    if senders[i] in receivers:
      for j in range(len(receivers[senders[i]])):
        ans.append(address[receivers[senders[i]][j]])
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for i in range(len(sending_addresses)):
    if sending_addresses[i] in ans:
      ans[sending_addresses[i]] += 1
    else:
      ans[sending_addresses[i]] = 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  cost = {}
  for i in range(len(senders)):
    if senders[i] in receivers:
      dis = 0
      for j in range(len(receivers[senders[i]])):
        dis += get_distance(address[receivers[senders[i]][j]], dispatch_center_addr)
      disfordis = dis
      alreadydis = False
      if dis > 10:
        c = 20+(dis-10)*3
      elif dis <= 10:
        c = dis*2
      while not alreadydis:
        if disfordis not in discount:
          disfordis -= 1
        else:
          c -= discount[disfordis]
          alreadydis = True
        if disfordis < 0:
          alreadydis = True
      cost[senders[i]] = c
    else:
      cost[senders[i]] = 0
  for i in cost:
    if cost[i] < 0:
      cost[i] = 0
  return cost
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans = []
  for i in dispatch_centers:
    cost = 0
    d = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    for j in d:
      cost += d[j]
    if ans == []:
      ans = [i, cost]
    elif ans[1] > cost:
      ans = [i, cost]
    elif ans[1] == cost:
      if ans[0] > i:
        ans = [i, cost]
  return ans

xxx040xxxx: HW9
bytecount: {'code': 658, 'const': 162, 'code+const': 820}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  receivers_name=[] ; house_num=[]
  for e in senders:
    if e in receivers:
      receivers_name.extend(receivers[e])
  for e in receivers_name:
    if e in address:
      house_num.append(address[e])
  return house_num
def get_item_count(sending_addresses) :
  house_num_parcel={}
  for e in sending_addresses:
    if e not in house_num_parcel:
      house_num_parcel[e]=1
    else:
      house_num_parcel[e]+=1
  return house_num_parcel
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  name_distance={} ; name_price={} ; name_discount={} ; name_discountPrice={}
  for e in senders:
    if e not in receivers:
      name_distance[e]=0
    else:
      l_house_num=get_sending_addresses([e], receivers, address)
      for house_num in l_house_num:
        distance=get_distance(dispatch_center_addr,house_num)
        if e not in name_distance:
          name_distance[e]=distance
        else:
          name_distance[e]+=distance
  for k in name_distance:
    if name_distance[k] <= 10:
      name_price[k]=name_distance[k]*2
    else:
      name_price[k]=20+(name_distance[k]-10)*3
  for k in name_distance:
    while name_distance[k] > 0:
      if name_distance[k] in discount:
        name_discount[k]=discount[name_distance[k]]
        break
      else:
        name_distance[k]-=1
  for k in name_price:
    if k not in name_discount:
      name_discountPrice[k]=name_price[k]
    elif name_price[k]-name_discount[k]<=0:
      name_discountPrice[k]=0
    else:
      name_discountPrice[k]=name_price[k]-name_discount[k]
  return name_discountPrice
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  distance_center=[]
  for k in dispatch_centers:
    name_discountPrice=calculate_fee(senders,receivers,address,discount,dispatch_centers[k])
    all_distance=0
    for name in name_discountPrice:
      all_distance+=name_discountPrice[name]
    distance_center.append([all_distance,k])
  distance_center.sort()
  return distance_center[0][::-1]

xxx021xxxx: HW9
bytecount: {'code': 680, 'const': 148, 'code+const': 828}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  namereceivers = []
  result = []
  for i in senders:
      if i in receivers:
          for j in receivers[i]:
              namereceivers.append(j)
  for k in namereceivers:
      result.append(address[k])
  return result
def get_item_count(sending_addresses) :
  result = {}
  for i in sending_addresses:
      if i not in result:
          result[i] = 1
      else:
          result[i] += 1
  return result
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  result = {}
  a = {}
  distance = 0
  discount2 = []
  for i in senders:
      a[i] = get_sending_addresses([i], receivers, address)
  for j in a:
      for k in a[j]:
          distance += get_distance(k,dispatch_center_addr)
      result[j] = distance
      distance = 0
  for i in discount:
        discount2.append(i)
  for n in result:
        c = 0
        for j in range(len(discount2)):
            if result[n] >= discount2[j]:
                c = discount2[j]
        if result[n] <= 10:
            if c != 0:
                result[n] = 2 * result[n] - discount[c]
                if result[n] < 0:
                    result[n] = 0
            else:
                result[n] = 2 * result[n]
        else:
            if c != 0:
                result[n] = 2 * 10 + 3 * (result[n] - 10) - discount[c]
                if result[n] < 0:
                    result[n] = 0   
            else:
                result[n] = 2 * 10 + 3 * (result[n] - 10)
  return result
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  result = []
  for i in dispatch_centers:
      ruam = 0
      x = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
      for j in x:
          ruam += x[j]
      result.append([ruam,i])
  result.sort()
  finalresult = result[0][-1::-1]
  return finalresult

xxx120xxxx: HW9
bytecount: {'code': 668, 'const': 162, 'code+const': 830}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans = []
  for k in senders :
      if k in receivers :
          for K in receivers[k] :
              ans.append(address[K])
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for k in sending_addresses :
      if k not in ans :
          ans[k] = 1
      else :
          ans[k] += 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  ans = {}
  for k in senders :
      if k not in receivers :
          ans[k] = 0
      else :
          to_address = get_sending_addresses([k], receivers, address)
          dis = 0
          tot_dis = 0
          for add in to_address :
              dis = get_distance(add, dispatch_center_addr)
              tot_dis += dis
          money = 0
          if tot_dis <= 10 :
              money += tot_dis*2
          else :
              money += 10*2
              tot_dis -= 10
              money += tot_dis*3
              tot_dis += 10
          discon = []
          for K in discount :
              discon.append([int(K),int(discount[K])])
          real_dis = 0
          discon.sort()
          for e in discon :
              if tot_dis >= e[0] :
                  real_dis = e[1]
              else :break
          ans[k] = (max(0, money - real_dis))
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans = []
  anss = []
  for dispatch in dispatch_centers :
      S = 0
      P = 0
      x = calculate_fee(senders, receivers, address, discount, dispatch_centers[dispatch]) 
      for key in x :
          S += x[key]
      if len(ans) == 0 :
          ans.append([0, dispatch])
      for i in range(len(ans)) :
          if ans[i][1] == dispatch :
              ans[i][0] += S
              P = 1
              break
      if P == 0 :
          ans.append([S, dispatch])
  ans.sort()
  for value,dispatch in ans :
        anss.append([dispatch, value]) 
  return anss[0]

xxx038xxxx: HW9
bytecount: {'code': 626, 'const': 204, 'code+const': 830}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  l = []
  x = []
  for key in senders:
    if key in receivers:
      for e in receivers[key]:
        l.append(e)
  for e in l:
    if e in address:
      x.append(address[e])
  return x
def get_item_count(sending_addresses) :
  numberOfItemToSend = {}
  for e in sending_addresses:
    numberOfItemToSend[e] = 0
  for e in sending_addresses:
    numberOfItemToSend[e] += 1
  return numberOfItemToSend
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = {}
  for e in senders:
    fee[e] = 0
  listOfDiscount = []
  for key in discount:
    listOfDiscount.append(key)
  listOfDiscount.sort(reverse = True)
  for key in fee:
    if key in receivers:
      totalDistance = 0
      for e in receivers[key]:
        totalDistance += get_distance( address[e] ,dispatch_center_addr )
      if totalDistance <= 10:
        price = totalDistance*2
      elif totalDistance >= 10:
        price = 20 + (totalDistance - 10)*3
      haveDiscount = False
      for distance in listOfDiscount:
        if totalDistance >= distance:
          selectedDiscount = distance
          haveDiscount = True
          break
      if haveDiscount:
        price -= discount[selectedDiscount]
      if price < 0:
        price = 0
      fee[key] = price
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  feeForEachDispatchCenter = {}
  listOfFee = []
  for key in dispatch_centers:
    d = calculate_fee(senders, receivers, address, discount, dispatch_centers[key])
    totalFeeForDispatchCenters = 0
    for e in d:
      totalFeeForDispatchCenters += int(d[e])
    feeForEachDispatchCenter[key] = totalFeeForDispatchCenters
    listOfFee.append(totalFeeForDispatchCenters)
  listOfFee.sort()
  minFee = min(listOfFee)
  listOfBestDispatchCenter = []
  for key in feeForEachDispatchCenter:
    if feeForEachDispatchCenter[key] == minFee:
      listOfBestDispatchCenter.append(key)
  listOfBestDispatchCenter.sort()
  nameOfBestDispatch = listOfBestDispatchCenter[0]
  bestDispatch = [nameOfBestDispatch, feeForEachDispatchCenter[nameOfBestDispatch]]
  return bestDispatch

xxx018xxxx: HW9
bytecount: {'code': 684, 'const': 148, 'code+const': 832}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    house_no = []
    for e in senders :
        if e in receivers :
            to = receivers[e]
            for k in to :
                house_no.append(address[k])
    return house_no
def get_item_count(sending_addresses) :
   parcels = {}
   for e in sending_addresses :
      if e not in parcels :
         parcels[e] = 1
      else :
         parcels[e] += 1
   return parcels
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    fee = {}
    distance = {}
    dcount = []
    for e in senders :
        fee[e] = 0
        if e in receivers :
            distance[e] = 0
    for m in discount :
        dcount.append(m)
    for c in senders :
        if c in receivers : 
            for k in receivers[c] : 
                distance[c] += get_distance(address[k],dispatch_center_addr)   
    maxxi = []
    for l in distance : 
        if distance[l] <= 10 :
            fee[l] += 2*distance[l]
        else :
            left = distance[l] - 10
            fee[l] += 2*10 + left*3
        compared = distance[l]
        for d in dcount :
            if d <= compared :
                maxxi.append(d)
        if len(maxxi) > 0 :
            fee[l] -= discount[max(maxxi)]
            maxxi = []
    for a in fee :
        if fee[a] < 0 :
            fee[a] = 0
    return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    location = {}
    maxxi = []
    for k in dispatch_centers :
        location[k] = 0
    for e in dispatch_centers :
        sum = 0
        fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[e]) 
        for c in fee :
            sum += fee[c]
        location[e] += sum
    for m in location :
        maxxi.append([location[m],m])
    maxxi.sort()
    return maxxi[0][::-1]

xxx122xxxx: HW9
bytecount: {'code': 674, 'const': 162, 'code+const': 836}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  out = []
  for sender in senders:
    if sender in receivers:
      listreceiver = receivers[sender]
      for receiver in listreceiver:
        if receiver in address: out.append(address[receiver])
  return out
def get_item_count(sending_addresses) :
  out = {}
  for e in sending_addresses:
    if e not in out: out[e] = 1
    else: out[e] += 1
  return out
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  data = {}
  for sender in senders:
    data[sender] = get_sending_addresses([sender],receivers, address)
  alldistance = {}
  for sender,recievers in data.items():
    alldistance[sender] = 0
    for reciever in recievers:
      alldistance[sender] += get_distance(reciever,dispatch_center_addr)
  howmuch = {}
  for sender,distance in alldistance.items():
    if distance-10 <= 0: howmuch[sender] = distance*2
    else: howmuch[sender] = (10)*2 + (distance-10)*3
  rediscount = []
  for k,v in discount.items(): rediscount.append([k,v])
  rediscount.sort()
  for sender,distance in alldistance.items():
    for dist,disc in rediscount[::-1]:
      if dist <= distance: howmuch[sender] -= disc ; break
  for k,v in howmuch.items():
    if howmuch[k] <= 0 : howmuch[k] = 0   
  return howmuch
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  data = []
  for k,v in dispatch_centers.items():
    data.append([k,calculate_fee(senders, receivers, address, discount, v)])
  out = []
  for name,sumall in data:
    s = 0
    for v in sumall.values(): 
      s += v
    out.append([s,name])
  out.sort()
  return out[0][::-1]

xxx030xxxx: HW9
bytecount: {'code': 646, 'const': 196, 'code+const': 842}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def find_km(distance,discount):
    km = []
    for e in discount.keys():
        km.append(e)
    max_dis = 0
    for i in range(len(km)-1):
        if km[i] <= distance < km[i+1]:
            max_dis = km[i]
        elif distance >= km[-1]:
            max_dis = km[-1]
    return max_dis
def get_sending_addresses(senders, receivers, address) :
    all_rec = []
    final = []
    ad = []
    for e in senders:
        if e in receivers:
            for n in receivers[e]:
                all_rec.append(n)
    for c in all_rec:
        ad.append(address[c])
    return ad
def get_item_count(sending_addresses) :
    ad_item = {}
    for e in sending_addresses:
        if e not in ad_item:
            ad_item[e] = 1
        else:
            ad_item[e] += 1
    return ad_item
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    fee = {}
    for e in senders:
        if e in receivers:
            distance = 0
            pay = 0
            for m in receivers[e]:
                distance += get_distance(address[m],dispatch_center_addr)
            disc_km = find_km(distance,discount)
            disc = 0
            if disc_km <=0:
                disc = 0
            else:
                disc = discount[disc_km]    
            if distance <= 10:
                pay += 2*distance - disc
            else:
                pay += 2*10 + (distance-10)*3 -disc
            if pay <= 0 :
                fee[e] = 0
            else:
                fee[e] = pay
        else: fee[e] = 0
    return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    place = []
    for e in dispatch_centers:
        f = 0
        all_people = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        for x in all_people.values():
            f += x
        each_place = [f,e]
        place.append(each_place)
    place.sort()
    cheap = place[0][::-1]
    return cheap

xxx020xxxx: HW9
bytecount: {'code': 644, 'const': 200, 'code+const': 844}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address):
  r = []
  for i in senders:
      if i in receivers:
          a = receivers[i]
          for k in a:
              b = address[k]
              r.append(b)
  return r
def get_item_count(sending_addresses):
  r = {}
  for i in sending_addresses:
      if i in r:
          r[i] += 1
      else:
          r[i] = 1
  return r
def howmuch(km):
  if km <= 10:
      return 2*km
  elif km > 10:
      return 20+3*(km-10)
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr):
  r = {}
  kmdis = []
  for i in discount:
      kmdis.append(i)
  kmdis.sort()
  for i in senders:
      km = dis = 0
      if i in receivers:
          a = receivers[i]
          for k in a:
              y = address[k]
              km += get_distance(dispatch_center_addr,y)
          for n in range(len(kmdis)):
              if km == kmdis[n]:
                  t = kmdis[n]
                  dis = discount[t]
                  break
              elif km <= kmdis[0]:
                  dis = 0
                  break
              elif km >= kmdis[-1]:
                  t = kmdis[-1]
                  dis = discount[t]
                  break
              elif km < kmdis[n]:
                  t = kmdis[n-1]
                  dis = discount[t]
                  break
          pay = howmuch(km) - dis
          if pay < 0: pay = 0
          r[i] = pay
      else: r[i] = 0
  return r
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  a = []
  min_p = 10e50
  for i in dispatch_centers:
      dispatch_center_addr = dispatch_centers[i]
      pay = calculate_fee(senders, receivers, address, discount, dispatch_center_addr)
      price = 0
      for k in pay:
          price += pay[k]
      a.append([price,i])
  a.sort()
  return a[0][::-1]

xxx042xxxx: HW9
bytecount: {'code': 678, 'const': 176, 'code+const': 854}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  re = []
  for s in senders :
      if s in receivers :
          x = receivers[s]
          for r in x :
              pre = address[r]
              re.append(pre)
  return re
def get_item_count(sending_addresses) :
  pre = {}
  for ch in sending_addresses :
      if ch not in pre :
          pre[ch] = 1
      else :
          pre[ch] += 1
  return pre
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  re = {}
  for x in senders :
      re[x] = 0
  for s in senders :
      if s in receivers :
          y = get_sending_addresses([s], receivers, address)
          c = 0
          for n in y :
              c += get_distance(n,dispatch_center_addr)
          if c > 10 :
              co = 0
              co += 10*2 + (c - 10)*3
          elif c <= 10 :
              co = 0
              co += c*2
          if len(discount) != 0 :
              d = []
              for nd in discount :
                  d.append(nd)
              d.sort()
              if c < d[0] :
                  z = 0
              elif c >= d[-1] :
                  z = discount[d[-1]]
              else :
                  for di in range(1,len(d)) :
                      if d[di - 1] <= c < d[di] :
                          z = discount[d[di - 1]]
          else :
              z = 0
          re[s] = co - z
  for zch in re :
      if re[zch] < 0 :
          re[zch] = 0  
  return re
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ch = []
  for c in dispatch_centers :
      fcf = calculate_fee(senders, receivers, address, discount, dispatch_centers[c])
      co = 0
      for s in fcf :
          co += fcf[s]
      ch.append([co, c])
  ch.sort()
  re = ch[0]
  re = re[::-1]
  return re

xxx219xxxx: HW9
bytecount: {'code': 640, 'const': 217, 'code+const': 857}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  r = []
  for i in senders :
    if i in receivers :
      for k in receivers[i] :
        r.append(address[k])
  return r
def get_item_count(sending_addresses) :
  w ={}
  for i in sending_addresses :
    if i in w :
      w[i] += 1
    else :
      w[i] = 1
  return w
def get_distance(address1, address2):
  address1 = int(address1.strip().replace("/",""))
  address2 = int(address2.strip().replace("/",""))
  return abs(address1-address2)
def expenses(dist, discount):
  hellomate = -9999
  for k in discount:
    if hellomate <= k <= dist: 
      hellomate = k
  return max(min(dist, 10) * 2 + max(dist - 10, 0) * 3 - discount.get(hellomate, 0), 0)
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  dontknow = {}
  loveyou = {}
  for i in senders:
    if i not in loveyou: 
      loveyou[i] = 0
    if i in receivers:
      for k in receivers[i]: loveyou[i] += get_distance(dispatch_center_addr, address[k])
  for i in loveyou: dontknow[i] = expenses(loveyou[i], discount)
  return dontknow
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  love = dict()
  dontknow = dict()
  rt = []
  for whyuocomb in dispatch_centers:
      dontknow[whyuocomb] = calculate_fee(senders, receivers, address, discount, dispatch_centers[whyuocomb])
  for whyuocomb in dontknow:
      love[whyuocomb] = sum([int(dontknow[whyuocomb][e]) for e in dontknow[whyuocomb]])
  rt = []
  for i in love:
    rt.append([love[i], i])
  S = min(rt)
  return S[::-1]

xxx031xxxx: HW9
bytecount: {'code': 688, 'const': 170, 'code+const': 858}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  x=[]
  for e in senders:
      if e in receivers:
          y=receivers[e]
          for a in y:
              if a in address:
                  x.append(address[a])
  return x
def get_item_count(sending_addresses) :
  x={}
  for e in sending_addresses:
      if not e in x:
          x[e]=1
      else:
          x[e]+=1
  return x
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  x={}
  for e in senders:
      y=get_sending_addresses([e],receivers,address)
      x[e]=y
  for e in x:
      f(x[e],dispatch_center_addr)
      x[e]=[sum(x[e])]
  for e in x:
      km=x[e][0]
      for r in sorted(discount)[::-1]:
          if km>=r:
              x[e].append(discount[r])
              break
      else:
          x[e].append(0)
  for e in x:
      km=x[e][0]
      if km>=10:
          price=(km-10)*3+10*2
      else:
          price=km*2
      x[e][0]=price
  for e in x:
      tp=x[e][0]-x[e][1]
      if tp<0:
          x[e]=0
      else:
          x[e]=tp 
  return x
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  x={}
  for e in dispatch_centers:
    dict_cost=calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    s=0
    for u in dict_cost:
      s+=dict_cost[u]
    x[e]=s
  min_cost=min(x.values())
  for e in sorted(x):
    if x[e]==min_cost:
      return [e,x[e]]
def f(x,r):
    for i in range(len(x)):
        x[i]=get_distance(x[i],r)

xxx203xxxx: HW9
bytecount: {'code': 696, 'const': 162, 'code+const': 858}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans = []
  for a in senders:
    if a in receivers:
      for b in receivers[a]:
        ans.append(address[b])
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for e in sending_addresses:
    if e in ans:
      ans[e] += 1
    else:
      ans[e] = 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  namedis = {}
  zin = {}
  for a in senders:
    dis = 0
    housenumber = get_sending_addresses([a], receivers, address)
    for b in housenumber:
      dis += get_distance(dispatch_center_addr,b)
    namedis[a] = dis
  for e in namedis:
    if namedis[e] <= 10:
      zin[e] = namedis[e]*2
    elif namedis[e] > 10:
      zin[e] = 20 + (int(namedis[e])-10)*3
  for e in namedis:
    while namedis[e] not in discount:
      namedis[e] -= 1
      if namedis[e] <= 0:
        break
  for e in zin:
    if namedis[e] in discount:
      zin[e] -= discount[namedis[e]]
  for e in zin:
    if zin[e] < 0:
      zin[e] = 0
  return zin
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  son = {}
  ans = []
  final = []
  ake = []
  for e in dispatch_centers:
    c = 0
    zin = calculate_fee(senders, receivers, address, discount,dispatch_centers[e])
    for a in zin:
      c += zin[a]
    son[e] = c
  for e in son:
    y = []
    y.append(son[e])
    y.append(e)
    ans.append(y)
  ans.sort()
  for e in ans:
    if ans[0][0] == e[0]:
      ake.append([e[1], e[0]])
  ake.sort()
  return ake[0]

xxx206xxxx: HW9
bytecount: {'code': 686, 'const': 174, 'code+const': 860}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  s = list()
  for n in senders :
    if n in receivers :
      for r in receivers[n] :
        s.append(r)
  return [address[i] for i in s]
def get_item_count(sending_addresses) :
  result = dict()
  for i in sending_addresses :
    if i not in result :
      result[i] = 0
    result[i] += 1
  return result
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  fee = dict() ; dis2fee = list()
  for n in senders :
    dis2fee.append(get_sending_addresses([n],receivers, address))
  for i in range(len(dis2fee)) :
    if len(dis2fee[i]) == 0 :
      dis2fee[i] = []
    else :
      for k in range(len(dis2fee[i])) :
        dis2fee[i][k] = get_distance(dispatch_center_addr,dis2fee[i][k])
    if len(dis2fee[i]) == 0 :
      dis2fee[i] = 0
    else :
      skm = sum(dis2fee[i])
      for d in sorted(discount.keys())[::-1] :
        if skm >= d :
          if skm <= 10 :
            dis2fee[i] = max(2*skm - discount[d],0)
          else :
            dis2fee[i] = max(2*10 + (skm-10) *3 - discount[d],0)
          break
      else :
        if skm <= 10 :
          dis2fee[i] = 2*skm 
        else :
          dis2fee[i] = 2*10 + (skm-10) *3
  for i in range(len(senders)) :
    if senders[i] not in fee :
      fee[senders[i]] = dis2fee[i]
  return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  eachfee = list()
  for p in dispatch_centers.keys() :
    fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[p])
    eachfee.append([sum(fee.values()),p])
  return sorted(eachfee)[0][::-1]

xxx026xxxx: HW9
bytecount: {'code': 714, 'const': 148, 'code+const': 862}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :  
    recieve_name = []
    for send in senders:
        for k,v in receivers.items():
            if send == k:
                for name in v:
                    recieve_name.append(name)
    add = []
    for name in recieve_name:
        add.append(address[name])
    return add
def get_item_count(sending_addresses) :
    item_each_house = {}
    for ad in sending_addresses:
        if ad not in item_each_house:
            item_each_house[ad] = 1
        else:
            item_each_house[ad] += 1
    return item_each_house
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    price_each = {}
    dsct = [int(e) for e in discount]
    dsct.sort()                    
    for send in senders:              
        if send not in receivers:
            price_each[send] = 0
        else:
            house = get_sending_addresses([send], receivers, address) 
            sum_dist = 0
            for i in house:
                dist = get_distance(i, dispatch_center_addr)   
                sum_dist += dist                                
            if dsct != []:    
              for z in range(len(dsct)-1): 
                  if dsct[z] <= sum_dist < dsct[z+1]: 
                      lodraka = discount[dsct[z]]
                      break
              if sum_dist < min(dsct):                
                  lodraka = 0
              elif sum_dist >= max(dsct):             
                  lodraka = discount[max(dsct)]
            else:
                lodraka = 0
            if sum_dist <= 10:                      
                price = sum_dist*2
            elif sum_dist > 10:                     
                price = (10*2) + (sum_dist-10)*3
            price_dis = price - lodraka
            if price_dis < 0:
                price_dis = 0
            price_each[send] = price_dis
    return price_each
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    location, b = [], {}
    for place in dispatch_centers:  
        all_price = calculate_fee(senders, receivers, address, discount, dispatch_centers[place]) 
        a = [e for e in all_price.values()] 
        b[place] = sum(a)                    
    minprice = min(b.values())
    for k,v in b.items():
        if v == minprice:
            location.append(k)  
    location2 = sorted(location)
    return [location2[0], minprice]

xxx029xxxx: HW9
bytecount: {'code': 630, 'const': 236, 'code+const': 866}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    whoget = []
    for a in senders:
        whoget += receivers.get(a, []) 
    final = [address.get(b) for b in whoget]
    return final
def get_item_count(sending_addresses) :
    final = {}
    for a in sending_addresses:
        if a in final:
            final[a] += 1
        else:
            final[a] = 1
    return final
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    sending = {}
    compare = list(discount)
    kilo = {}
    price = {}
    for a in senders:
        sending[a] = get_sending_addresses([a], receivers, address)
    for b,c in sending.items():
        howfar = 0
        for d in c:
            howfar += get_distance(d,dispatch_center_addr)
        kilo[b] = howfar
    for e,f in kilo.items():
        pls = [x for x in compare if f >= x]
        if f < 10:
            price[e] = f * 2
        else:
            price[e] = 10 * 2 + (f - 10) * 3
        if price[e] > 0 and pls != []:
            price[e] -= discount[pls[-1]]
        if price[e] <= 0:
            price[e] = 0
    return price
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    almost = {}
    yo = []
    for a in dispatch_centers:
        yo = calculate_fee(senders, receivers, address, discount, dispatch_centers[a])
        what = 0
        for b in yo.values():
            what += b
        almost[a] = what
    passingby = list(almost.items())
    final = sorted(sorted(passingby,key = lambda x : x[0]), key = lambda x: x[1])
    finale = [final[0][0],final[0][1]]
    return finale

xxx044xxxx: HW9
bytecount: {'code': 724, 'const': 148, 'code+const': 872}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  s = []
  for i in range(len(senders)):
    if senders[i] in receivers.keys():
      s+=(receivers[senders[i]])
  ss = []
  for i in range(len(s)):
    if s[i] in address.keys():
      ss.append(address[s[i]])
  return ss
def get_item_count(sending_addresses) :
  d = {}
  for i in range(len(sending_addresses)):
    if sending_addresses[i] not in d:
      d[sending_addresses[i]] = 1
    else:
      d[sending_addresses[i]] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  ss = []
  for k in discount.keys():
    ss.append(k)
  for i in range(len(senders)):
    home = get_sending_addresses([senders[i]], receivers, address)
    km = 0
    for j in range(len(home)):
      km += get_distance(home[j], dispatch_center_addr)
    if km<=10:
      cash1 = km*2
    else:
      cash1 = 20 + ((km-10)*3)
    dsc = 0
    for e in range(len(ss)):
      if km >= ss[e]:
        dsc = discount[ss[e]]
    cash2 = cash1 - dsc
    if cash2 < 0:
      cash2 = 0
    d[senders[i]] = cash2
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  s = []
  dc = []
  for kk,vv in dispatch_centers.items():
    dc.append([kk,vv])
  for i in range(len(dc)):
    d = calculate_fee(senders, receivers, address, discount, dc[i][1])
    cash = 0
    for k,v in d.items():
      cash += v
    s.append([dc[i][0], cash])
  for i in range(len(s)):
    s[i][0], s[i][1] = s[i][1], s[i][0]
  ss = sorted(s)
  return [ss[0][1], ss[0][0]]

xxx018xxxx: HW9
bytecount: {'code': 702, 'const': 174, 'code+const': 876}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  d = []
  for x in senders:
      if x in receivers:
          d.append(receivers[x])
  s = []
  for i in range(len(d)):
      for x in d[i]:
          if x in address:
              s.append(address[x])
  return s
def get_item_count(sending_addresses) :
  d = {}
  for x in sending_addresses:
      d[x] = 0
  for x in sending_addresses:
      d[x] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  dislist = []
  for x in discount:
      dislist.append([x,discount[x]])
  for x in senders:
      if x in receivers:
          dis = 0
          for y in receivers[x]:
              if y in address:
                  dis += get_distance(address[y],dispatch_center_addr)
          price = 0
          if dis > 10 :
              price += 10*2
              dis2 = dis-10
              price += dis2*3
          else:
              price += dis*2
          for i in range(len(dislist)):
              if dislist[i][0] == dis:
                  price -= dislist[i][1]
                  break
              elif i > 0 and dislist[i][0] > dis:
                  price -= dislist[i-1][1]
                  break
              elif i == len(dislist)-1 and dislist[i][0] < dis:
                  price -= dislist[i][1]
                  break
          if price < 0 :
              price = 0
          d[x] = price
      else:
          d[x] = 0
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  location = []
  for x in dispatch_centers :
      disall = calculate_fee(senders, receivers, address, discount, dispatch_centers[x])
      price = 0
      for y in disall:
          price += disall[y]
      location.append([price,x])
  x = min(location)
  y = []
  y.append(x[1])
  y.append(x[0])
  return y

xxx207xxxx: HW9
bytecount: {'code': 728, 'const': 148, 'code+const': 876}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans = []
  for e in senders :
    if e in receivers :
      for f in receivers[e] :
        ans.append(address[f])
    else :
      pass
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for e in sending_addresses :
    if e in ans :
      ans[e] += 1
    else :
      ans[e] = 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  ans = {}
  c = 0
  n_discount = [0]*len(senders)
  list_discount = []
  for e in discount :
    list_discount.append(e)
  for e in senders :
    ans[e] = 0
  for e in senders :
    if e in receivers :
      for f in receivers[e] :
        ans[e] += abs(get_distance(address[f],dispatch_center_addr))
    else :
      pass
  for e in ans :
    for i in range(len(list_discount)) :
      if ans[e] >= list_discount[i] :
        n_discount[senders.index(e)] = discount[list_discount[i]]
      else :
        break
  for e in ans : 
    if ans[e] > 10 :
      c += ((ans[e]-10)*3) + (10*2)
      ans[e] = c
      c = 0
    else :
      c += ans[e]*2
      ans[e] = c
      c = 0
  for e in senders :
    if n_discount[senders.index(e)] > ans[e] :
      ans[e] = 0
    else :
      ans[e] -= n_discount[senders.index(e)]
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  c = 0
  ans = []
  centers = []
  n = []
  for e in dispatch_centers :
    for f in calculate_fee(senders, receivers, address, discount, dispatch_centers[e]) :
      c += calculate_fee(senders, receivers, address, discount, dispatch_centers[e])[f]
    n.append(c)
    centers.append([e,c])
    c = 0
  for e in centers :
    if e[1] == min(n) :
      ans.append(e) 
  ans.sort()
  return ans[0]

xxx017xxxx: HW9
bytecount: {'code': 686, 'const': 196, 'code+const': 882}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    l = []
    for i in range(len(senders)):
        if senders[i] in receivers:
            for j in range(len(receivers[senders[i]])):
                l.append(address[receivers[senders[i]][j]])
    return l
def get_item_count(sending_addresses) :
    count = {}
    for address in sending_addresses:
        if address not in count:
            count[address] = 1
        else:
            count[address] +=1
    return count
def calculate_discount (distance,discount):
    lst = []
    s = 0
    for dist in discount:
        lst.append([dist,discount[dist]])
    lst.sort()
    lst = lst[::-1]
    for i in range(len(lst)):
        if distance>=lst[i][0]:
            s = lst[i][1]
            break
    return s
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    fee = {}
    for i in range(len(senders)):
        send_address = get_sending_addresses([senders[i]], receivers, address)
        money = 0
        distance = 0
        for j in range(len(send_address)):
            distance += get_distance(send_address[j],dispatch_center_addr)
        if distance <=10:
            money = distance * 2 - calculate_discount (distance,discount)
        else:
            money = 10 * 2 + (distance - 10)*3 - calculate_discount (distance,discount)
        if money < 0:
            fee[senders[i]] = 0
        else:
            fee[senders[i]] = money
    return fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    list_dispatch_fee = []
    list_dispatch = []
    out = []
    for dispatch_name in dispatch_centers:
        fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[dispatch_name])
        sum_fee = 0
        for send_name in fee:
            sum_fee += fee[send_name]
        list_dispatch_fee.append(sum_fee)
        list_dispatch.append([dispatch_name,sum_fee])
    min_dispatch = min(list_dispatch_fee)
    for i in range(len(list_dispatch)):
        if list_dispatch[i][1] == min_dispatch:
            out.append(list_dispatch[i])
    out.sort()
    return out[0]

xxx215xxxx: HW9
bytecount: {'code': 752, 'const': 134, 'code+const': 886}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  listt=[]
  listr=[]
  lists=[]
  add=[]
  for i in receivers:
    listr.append(i) 
  for c in senders:
    if c in listr:
      lists.append(c) 
  for s in lists:
    recev=receivers[s] 
    for g in recev:
      add.append(g) 
  for t in add:
    final=address[t]
    listt.append(final) 
  return listt
def get_item_count(sending_addresses) :
  dictt={}
  for i in sending_addresses:
    if i not in dictt:
      dictt[i]=1
    else:
      dictt[i]+=1
  return dictt
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  listr=[]
  dict3={}
  for i in receivers:
    listr.append(i) 
  for s in senders:
    if s in listr: 
      cost=0
      dt=0
      dc=0
      lists=receivers[s]
      distance=0
      for g in lists:
        add=address[g]
        distance+=get_distance(add,dispatch_center_addr)
      if distance <=10:
        dt+=distance*2
      elif distance > 10:
        dt+=10*2
        dt+= (distance-10)*3
      cost+=dt
      for c in discount:
        if c <=distance:
          dc=discount[c]
      cost-=dc
      dict3[s]=cost
      if cost<0:
        dict3[s]=0 
    else:
      dict3[s]=0
  return dict3
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  list4=[]
  listd=[]
  for t in dispatch_centers:
    listd.append(t)
  listd.sort()
  for d in listd:
    if listd.index(d)==0:
      costt=0
    dict34=calculate_fee(senders, receivers, address, discount, dispatch_centers[d])
    costall=0
    for i in dict34:
      costall+=dict34[i]
    if costall==0:
      costt=costall
      dd=d
      break
    elif costall<costt:
      costt=costall
      dd=d
    elif costall>=costt and listd.index(d)==0:
      costt=costall
      dd=d
    elif costall>=costt and listd.index(d)!=0:
      continue
    else:
      costt=costall
      dd=d
  list4.append(dd)
  list4.append(costt)
  return list4

xxx213xxxx: HW9
bytecount: {'code': 730, 'const': 162, 'code+const': 892}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  list_address = []
  for e in senders:
    if e in receivers:
      list_receivers = receivers[e]
      for e in list_receivers:
        list_address.append(address[e]) 
  return list_address
def get_item_count(sending_addresses) :
  count_per_home = {}
  for e in sending_addresses:
    if e in count_per_home:
      count_per_home[e]+=1
    else:
     count_per_home[e]=1 
  return count_per_home
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  dic_address = {}
  dic_distance= {}
  dic_pay = {}
  dic_pay_discount ={}
  for e in senders:
    if e in receivers:
      k= []
      for t  in receivers[e]:
        k.append(address[t])
      dic_address[e] = k
    dic_distance[e]=0
  for e in dic_address:
    for j in dic_address[e]:
      dic_distance[e]+= get_distance(j, dispatch_center_addr)
  for e in dic_distance:
    if dic_distance[e] <= 10 :
       dic_pay[e] = 2*dic_distance[e]
    elif dic_distance[e]  >=10:
       dic_pay[e] = 2*(10) + 3*(dic_distance[e]-10)
  for e in dic_distance:
    for j in sorted(discount)[::-1]:
      if dic_distance[e] >= j:
         k = dic_pay[e]- discount[j]
         if k>0:
           dic_pay[e]-=discount[j]
         else:
           dic_pay[e] = 0
         break
  return  dic_pay
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  dic_center_pay = {}
  for e in dispatch_centers :
     dic_center_pay[e]=calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
  dic_pay_total = {}
  list_total  = []
  for center  in dic_center_pay :
      paid_total = 0
      for pay_sender in dic_center_pay[center]:
          paid_total+=dic_center_pay[center][pay_sender ]
      dic_pay_total[center] = paid_total
      list_total.append(paid_total)
  paid_min  = min(list_total)
  dic_bestplace = {}
  list_bestplace =[]
  for  place in  dic_pay_total:
      if dic_pay_total[place] == paid_min:
          dic_bestplace[place] = dic_pay_total[place]
  for place in sorted(dic_bestplace):
         list_bestplace.append(place)
         list_bestplace.append(dic_bestplace[place])
  return  list_bestplace[:2]

xxx019xxxx: HW9
bytecount: {'code': 704, 'const': 190, 'code+const': 894}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address):
    a=[]
    b=[]
    for i in senders:
        if i in receivers:
            for j in receivers[i]:
                    a.append(j)
    for i in a:
        b.append(address[i])
    return b
def get_item_count(sending_addresses) :
    d={}
    for i in sending_addresses:
        if i not in d:
            d[i]=1
        else:
            d[i]+=1
    return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    d={}
    for i in senders:
        d[i]=0
    for i in senders:
        a=0;b=0;c=[]
        if i in receivers:
            for j in receivers[i]:
                a+=get_distance(address[j],  dispatch_center_addr)
            if a<=10:
                b+=a*2
            else:
                b+=10*2+((a-10)*3)
            for m in discount:
                if a >= m:
                    c.append(m)
            if len(c)!=0:
                b-=discount[c[len(c)-1]]
            if b>=0:
                d[i]=b
            else:
                d[i]=0
    return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    d={};g=[];min=99999999999999999999999999999999;f=[]
    for i in dispatch_centers:
        v=0
        a=calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
        for j in a:
            v+=a[j]
        d[i]=v
    for i in d:
        if d[i]<=min:
            min=d[i]
    for i in d:
        if min==d[i]:
            g.append(i)
            if min >=0:
                g.append(min)
            else: 
                g.append(0)
    for i in dispatch_centers:
        if i in g:
            f.append(i)
    f=sorted(f)
    if len(g)==2:
        return g
    else:
        if min>=0:
            return [f[0],min]
        else:
            return [f[0],0]

xxx039xxxx: HW9
bytecount: {'code': 706, 'const': 190, 'code+const': 896}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ans=[]
  for sender in senders:
      if sender in receivers:
          for ad in receivers[sender]:
              if ad in address:
                  ans.append(address[ad])
  return ans
def get_item_count(sending_addresses) :
  ans={}
  for add in sending_addresses:
      if add not in ans:
          ans[add]=1
      else:ans[add]+=1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  ans={}
  price=0
  for i in senders:
    ans[i]=sending_address=get_sending_addresses([i], receivers, address)
  for e in ans:
    if ans[e]==[]:
      ans[e]=0
    else:
      dt=0
      dt2=0
      dc=0
      for ad in ans[e]:
        dt+=get_distance(ad,dispatch_center_addr)
        dt2+=get_distance(ad,dispatch_center_addr)
      for i in range(dt):
        if dt2 in discount:
          dc=discount[dt2]
          break
        else: 
          dt2-=1
      if dt<=10:
          price=dt*2
      else:
          price=10*2 + (dt-10)*3
      real=price-dc
      if real<0:
        real=0
      ans[e]=real
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  i=0
  ans=[]
  for dispatch in dispatch_centers:
    sum=0
    cf=calculate_fee(senders, receivers, address, discount, dispatch_centers[dispatch])
    for d in cf:
      sum+=cf[d]
    if i==0:
      min=sum
      i+=1
      ans.append(dispatch)
      ans.append(sum)
    else:
      if min==sum:
        ans[-1]=str(ans[-1])
        ans.append(dispatch)
        ans.sort()
        ans=ans[1:]+[ans[0]]
        ans[-1]=int(ans[-1])
      if sum < min:
        ans=[]
        min=sum
        ans.append(dispatch)
        ans.append(sum)
  if len(ans)==2:
    return ans
  else:
    ans2=[]
    ans2.append(ans[0])
    ans2.append(ans[-1])
    return ans2

xxx201xxxx: HW9
bytecount: {'code': 736, 'const': 162, 'code+const': 898}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  memory = []
  for n in senders:
    if n in receivers:
      for m in receivers[n]:
        memory.append(address[m])
  return memory
def get_item_count(sending_addresses) :
  memory = []
  itemCount = {}
  for i in sending_addresses:
    if i not in memory:
      memory.append(i)
      itemCount[i] = 1
    else:
      itemCount[i] += 1
  return itemCount
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  memory = {}
  for n in senders:
    if n in receivers:
      memory[n] = [address[m] for m in receivers[n]]
    elif n not in receivers:
      memory[n] = [dispatch_center_addr]
  calculatedFee = {}
  keys = [x for x in discount]
  keys.sort()
  for name in memory:
    fee = 0
    distance = 0
    for address in memory[name]:
        distance += get_distance(address, dispatch_center_addr)
    if distance > 10:
        fee += 10*2 + (distance - 10)*3
    else:
        fee += distance*2
    for i in range(len(keys)):
      try:
        if distance >= keys[i] and distance <= keys[i+1]:
          fee -= discount[keys[i]]
      except:
        fee -= discount[keys[-1]]
    if fee < 0:
      fee = 0
    calculatedFee[name] = fee
  return calculatedFee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  valueMemory = []
  locationMemory = []
  LastList = []
  for a in dispatch_centers:
    valueMemory.append(sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[a]).values()))
    locationMemory.append(a)
  sortedLocationMemory = [x for _, x in sorted(zip(valueMemory,locationMemory))]
  valueMemory.sort()
  duplicatedMin = []
  for i in valueMemory:
    if i == min(valueMemory):
      duplicatedMin.append(valueMemory.index(i))
  LastList = sorted(sortedLocationMemory[:len(duplicatedMin)])
  FinalList = [LastList[0], min(valueMemory)]
  return FinalList

xxx216xxxx: HW9
bytecount: {'code': 736, 'const': 162, 'code+const': 898}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    ans = []
    for e in senders :
        if e in receivers :
            k = receivers[e]
            for ch in k :
                if ch in address :
                    ans.append(address[ch])
    return ans
def get_item_count(sending_addresses) :
    ans = {}
    for e in sending_addresses :
        if e in ans :
            ans[e] += 1
        else :
            ans[e] = 1
    return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    sumkon = {}
    senderss = {}
    for kon in senders :
        senderss[kon] = 0
        if kon in receivers :
            sumkon[kon] = (get_sending_addresses([kon], receivers, address))
    ratedis = []
    for y in discount :
        ratedis.append(y)
    for ch in sumkon :
        k = sumkon[ch]
        totd = 0
        for add in k :
            totd+=get_distance(add,dispatch_center_addr)
        mon = 0
        if totd <= 10 :
            mon += totd*2                  
        else :
            mon += 20
            mon += (totd-10)*3
        dis = 0
        if len(ratedis) > 0 :
            if min(ratedis) <= totd < max(ratedis) :
                        for i in range(len(ratedis)-1) :
                            if ratedis[i] <= totd < ratedis[i+1] :
                                dis = discount[ratedis[i]]
            elif totd >= max(ratedis) :
                dis = discount[max(ratedis)]
            else :
                dis = 0
        if mon - dis >= 0 :
            senderss[ch] = (mon-dis)
        else :
            senderss[ch] = 0
    return senderss
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    ans = {}
    for ch in dispatch_centers :
        ans[ch] = dispatch_centers[ch]
    for k in dispatch_centers :
        sumkon = calculate_fee(senders, receivers, address, discount, dispatch_centers[k])
        totp = 0
        for p in sumkon :
            totp += sumkon[p]
        ans[k]  = totp
    reans = []
    for m in ans :
        reans.append([ans[m],m])
    reans.sort()
    return reans[0][::-1]

xxx035xxxx: HW9
bytecount: {'code': 726, 'const': 174, 'code+const': 900}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  recieve = []
  ans = []
  for name in senders:
    if name in receivers:
      recieve.append(receivers[name])
    else:
      pass
  for name in recieve:
    for i in range(len(name)):
      if name[i] in address:
        ans.append(address[name[i]])
    else:
      pass
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for ad in sending_addresses:
    ans[ad] = 0
  for ad in sending_addresses:
    if ad in ans:
      ans[ad] += 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    ans = {}
    dis = []
    for km in discount:
        dis.append([km,discount[km]])
        dis.sort()
    for name in senders: 
        d = 0
        if name in receivers:
          for ad in receivers[name]:
            d1 = address[ad]
            di = get_distance(d1,dispatch_center_addr)
            d += di
          ans[name] = d
        else:
          ans[name] = 0
          continue
    Disco = 0
    for name in ans:
        if ans[name] != 0:
            if ans[name] >= 10:
                for km in range(len(dis)):
                    if dis[km][0] <= ans[name] :
                        Disco = dis[km][1]
                ans[name] = 2*10 + (ans[name]-10)*3
            else:
                for km in range(len(dis)):
                    if dis[km][0] <= ans[name] :
                        Disco = dis[km][1]
                    else:
                        break
                if ans[name] < 10:
                    ans[name] = 2*ans[name]
            ans[name] -= Disco
            if ans[name] < 0 :
                ans[name] = 0
    return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans = []
  for k in dispatch_centers:
    cost = 0
    costlist = calculate_fee(senders, receivers, address, discount, dispatch_centers[k])
    for n in costlist:
      cost += costlist[n]
    ans.append([cost,k])
  x = sorted(ans)
  return x[0][::-1]

xxx036xxxx: HW9
bytecount: {'code': 780, 'const': 120, 'code+const': 900}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  z = []
  for e in senders :
      if e in receivers:
          z += receivers[e]
  y = []
  for e in z :
      if e in address :
          y.append(address[e])
  y.sort()
  return y
def get_item_count(sending_addresses) :
  z = {}
  for e in sending_addresses :
      if e in z :
          z[e] += 1
      else :
          z[e] = 1
  return z
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  a = []
  b = []
  dista = []
  dista1 = 0
  key = []
  disca = 0
  z = {}
  for e in senders :
      for k in receivers : 
          if e == k : 
              a += receivers[k] 
              for j in a :  
                  b.append(address[j]) 
              for j in b : 
                  dista.append(get_distance(j, dispatch_center_addr))
              for j in dista : 
                  dista1 += int(j) 
              for j in discount : 
                  key.append(j)  
              for j in key : 
                  if int(j) <= int(dista1) and int(j) > int(disca) :
                      disca = j
              if disca in discount :
                  disca = discount[disca]
              else : disca = 0
              price = 0
              if dista1 <= 10 :
                  price = dista1*2
              else :
                  price = dista1*3 - 10
              price = price - disca
              if price <= 0 :
                  price = 0
              z[e] =  price
          a = []
          b = []
          dista = []
          dista1 = 0
          key = []
          disca = 0
  for e in senders :
      if e not in z :
          z[e] = 0
  return z
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  x = 0
  y = {}
  mina = []
  z = []
  for e in dispatch_centers :
      a = calculate_fee(senders, receivers, address, discount, dispatch_centers[e] ) 
      for k in a : 
          x += int(a[k])
      y[e] = x
      x = 0
  for e in y : 
      mina.append(int(y[e]))
  mina = min(mina)
  for e in y :
      if y[e] == mina :
          z.append([e,int(y[e])])
  z.sort()
  z = z[0]
  return  z

xxx204xxxx: HW9
bytecount: {'code': 716, 'const': 188, 'code+const': 904}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  sending_addresses=[]
  for e in receivers:
      if e in senders:
          for j in receivers[e]:
              sending_addresses.append(address[j])
  return sending_addresses
def get_item_count(sending_addresses) :
  item_count={}
  for e in sending_addresses:
      item_count[e]=0
  for e in sending_addresses:
      item_count[e]+=1
  return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  dc=[]
  discountmax2min={}
  for e in discount:
      dc.append([e,discount[e]])
  dc.sort()
  dc=dc[::-1]
  for i in range(len(dc)):
      discountmax2min[dc[i][0]]=dc[i][1]
  total_fee={}
  for e in senders:
      total_fee[e]=0
  for e in receivers:
      d=0
      fee=0
      for r in receivers[e]:
          d+=get_distance(dispatch_center_addr,address[r])
          if r == receivers[e][-1]:
              if d>10:
                  fee=(d-10)*3+(10*2)
              else:
                  fee=d*2
              for j in discountmax2min:
                  if d>=j:
                      fee-=discountmax2min[j]
                      if fee<0:
                          fee=0
                      break
              if e in senders:
                  total_fee[e]=fee
  return total_fee
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  sum_fee={}
  for e in dispatch_centers:
      c=0
      total_fee=calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
      for j in total_fee:
          c+=total_fee[j]
      sum_fee[e]=c
  s=[]
  for e in sum_fee:
      s.append([sum_fee[e],e])
  min_fee=[]
  for i in range(len(s)):
      if s[i][0]==min(s)[0]:
          min_fee.append(s[i])
  min_fee.sort()
  for i in range(len(min_fee)):
    min_fee[i]=[min_fee[i][1],min_fee[i][0]]
  return min_fee[0]

xxx208xxxx: HW9
bytecount: {'code': 710, 'const': 194, 'code+const': 904}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  po_rub = []
  ans = []
  for i in senders:
    if i in receivers:
      a = receivers[i]
      for j in a:
        po_rub.append(j)
  for i in po_rub:
    if i in address:
      ans.append(address[i])
  return ans
def get_item_count(sending_addresses) :
  d = {}
  for i in sending_addresses:
    if i in d:
      d[i] += 1
    else:
      d[i] = 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  ans = {}
  disdis = []
  re = []
  for i in senders:
    d[i] = 0
  n_sen = senders
  senders = []
  for i in n_sen:
    if i in receivers:
      senders.append(i)
  for i in senders:
    a = receivers[i]  
    sum_dis = 0
    for j in a:
      dis = get_distance(dispatch_center_addr, address[j])
      sum_dis += dis
    d[i] = sum_dis
  for i in discount:
    disdis.append(i)
  disdis.sort(reverse = True)
  for i in d:
    if d[i] <= 10:
      ans[i] = d[i]*2
    else:
      b = d[i] - 10
      ans[i] = 10*2 + b*3
    for j in disdis:
      if j <= d[i]:
        c = discount[j]
        ans[i] = ans[i] - c
        break
  for i in ans:
    if ans[i] < 0:
      ans[i] = 0
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  station_address = []
  d = {}
  for i in dispatch_centers:
    a = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
    b = 0
    for j in a:
      b += a[j]
    d[i] = b
  dr = [[v,k] for k,v in d.items()]
  dr.sort()
  ans = [dr[0][1], dr[0][0]]
  return ans

xxx019xxxx: HW9
bytecount: {'code': 702, 'const': 209, 'code+const': 911}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_distance(address1, address2):
    address1 = int(address1.strip().replace("/",""))
    address2 = int(address2.strip().replace("/",""))
    return abs(address1-address2)
def get_sending_addresses(senders, receivers, address) :
    a = []
    for i in range(len(senders)):
        if senders[i] in receivers:
            a.append(receivers[senders[i]])
    b = []
    for i in range(len(a)):
        for e in range(len(a[i])):
            if a[i][e] in address:
                b.append(address[a[i][e]])
    return b
def get_item_count(sending_addresses) :
    a = {}
    for i in range(len(sending_addresses)):
        if sending_addresses[i] in a:
            a[sending_addresses[i]] += 1
        else:
            a[sending_addresses[i]] = 1
    return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    a = {}
    for i in senders:
        b = get_sending_addresses([i],receivers,address)
        dis = 0
        money = 0
        for e in b:
            c = get_distance(e,dispatch_center_addr)
            dis += c
        if dis > 10:
            money += 20 + (dis-10)*3
        else:
            money += dis*2
        lodraka = []
        for f in discount:
            lodraka.append(f)
        lodraka.sort()
        I = 0
        for g in range(len(lodraka)):
            if lodraka[g] <= dis:
                I = discount[lodraka[g]]
        money -= I
        if money < 0:
            a[i] = 0
        else:
            a[i] = money
    return a
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    b = [] 
    for i in dispatch_centers:
        a = calculate_fee(senders,receivers,address,discount,dispatch_centers[i])
        c = []
        for e in a:
            c.append(e)
        rakaruam = 0
        for r in c:
            rakaruam += a[r]
        b.append([rakaruam,i])
    M = min(b)
    return M[::-1]

xxx019xxxx: HW9
bytecount: {'code': 782, 'const': 134, 'code+const': 916}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    name = []
    x = []
    ans = []
    for i in senders:
        if i in receivers:
            name.append(i)
    for i in name:
        for k in receivers[i]:
            x.append(k)
    for i in x:
        if i in address:
            ans.append(address[i])
    return ans
def get_item_count(sending_addresses) :
    ans = {}
    for i in sending_addresses:
        if i in ans:
            ans[i] += 1
        else:
            ans[i] = 1
    return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    kilo = {}
    ans = {}
    dis = []
    for i in senders:
        if i in receivers:
            kilo[i] = 0
            x = 0
            for k in receivers[i]:
                x += get_distance(address[k],dispatch_center_addr)
            kilo[i] += x
        else:
            kilo[i] = 0
    for i in kilo:
        ans[i] = kilo[i]
    for i in kilo:
        if kilo[i] > 10:
            ans[i] = 10*2 + ((ans[i]-10)*3)
        else:ans[i] = ans[i]*2
    for i in discount:
        dis.append(i)
    dis.sort()
    for i in kilo:
        x = 0
        for k in dis:
            if kilo[i] >= k and kilo[i] >= x:
                x = k
        if x in discount:
            ans[i] = ans[i] - discount[x]
            if ans[i] < 0:
                ans[i] = 0
    return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    compare = {}
    name = []
    ans = []
    for i in dispatch_centers:
        price = calculate_fee(senders, receivers, address, discount, dispatch_centers[i])
        x = 0
        for k in price:
            x += price[k]
        compare[i] = x
    minvalue = min(compare.values())
    res = [k for k, v in compare.items() if v==minvalue]
    for i in compare:
        if i in res:
            name.append(i)
    name.sort()
    ans.append(name[0])
    ans.append(minvalue)
    return ans

xxx026xxxx: HW9
bytecount: {'code': 742, 'const': 176, 'code+const': 918}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  cal1 = []
  cal2 = []
  for list_re in senders:
      if list_re in receivers:
          cal1.append(receivers[list_re])
  for list_re in cal1:
      for e in list_re:
        cal2.append(address[e])
  return cal2
def get_item_count(sending_addresses) :
  ans = {}
  for e in sending_addresses:
      if e not in ans:
          ans[e] = 1
      else:
          ans[e] +=1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr):
  ans = {}
  for e in senders:
    ans[e] = 0
  for e in senders:
      if e in receivers:
        sum = 0
        price = 0
        dis = []
        for i in receivers[e]:
            cal_dis = get_distance(dispatch_center_addr,address[i])
            sum+=cal_dis
        if sum <=10:
            price+=(2*sum)
        elif sum>10:
            price+= (20+(sum-10)*3)              
        for i in discount:
            if sum>=i:
                dis.append(discount[i])
        if len(dis)>0:
          price-=dis[-1]
        if price<0:
            price = 0
        ans[e]=price
  return ans
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ans_center = []
  ans = []
  for e in dispatch_centers:
      x = dispatch_centers[e]
      y = calculate_fee(senders, receivers, address, discount ,x)
      sum = 0
      for i in y:
        sum+=y[i]
      ans_center.append([sum,e])
  ans_center = sorted(ans_center)
  for i in range(len(ans_center)-1):
      x = ans_center[i][0]
      y = ans_center[i+1][0]
      if x!=y:
        ans.append(ans_center[i])
      else:
        list_check = []
        g = ans_center[i][::-1]
        h = ans_center[i+1][::-1]
        list_check.append(g)
        list_check.append(h)
        list_check = sorted(list_check)
        ans.append(list_check[0][::-1])
        ans.append(list_check[1][::-1])
        i = i+1
  return ans[0][::-1]

xxx209xxxx: HW9
bytecount: {'code': 722, 'const': 204, 'code+const': 926}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    out = []
    for i in senders:
        if i in receivers:
            rec = receivers[i]
            for j in rec:
                if j in address:
                    out.append(address[j])
    return out
def get_item_count(sending_addresses) :
    out = {}
    for i in sending_addresses:
        if i not in out:
            out[i] = 1
        else:
            out[i] += 1
    return out
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    note = {}
    for i in senders:
        out = []
        total = []
        if i in receivers:
            rec = receivers[i]
            for j in rec:
                if j in address:
                    total.append(get_distance(address[j], dispatch_center_addr))
        note[i] = sum(total)
    for i in note:
        b = 0 
        if note[i] <= 10:
            price = note[i]*2
        else:
            price = (10*2)+((note[i]-10)*3)
        for j in discount:
            if note[i] >= j:
                b = discount[j]
        price -= b
        if price <= 0:
          price = 0
        note[i] = price
    return note
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    new = {}
    for o in dispatch_centers:
        use = 0
        note = {}
        for i in senders:
            out = []
            total = []
            if i in receivers:
                rec = receivers[i]
                for j in rec:
                    if j in address:
                        total.append(get_distance(address[j], dispatch_centers[o]))
            note[i] = sum(total)
        for i in note:
            b = 0 
            if note[i] <= 10:
                price = note[i]*2
            else:
                price = (10*2)+((note[i]-10)*3)
            for j in discount:
                if note[i] >= j:
                    b = discount[j]
            price -= b
            if price <= 0:
              price = 0
            use += price
        new[o] = use
    final = []
    for k,v in new.items():
        final.append([v,k])
    final.sort()
    return [final[0][1],final[0][0]]

xxx216xxxx: HW9
bytecount: {'code': 742, 'const': 184, 'code+const': 926}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) : 
  l_of_receivers=[]
  l_of_address=[]
  for i in senders :
      if(i in receivers) :
          l_of_receivers.append(receivers[i])
  for i in l_of_receivers :
      for j in i :
          l_of_address.append(address[j])
  l_of_address.sort()
  return l_of_address
def get_item_count(sending_addresses) : 
  d={}
  for i in sending_addresses :
      if(i in d) :
          d[i]+=1
      else :
          d[i]=1
  return d
def send_receive_addr(senders,receivers,address) :
    d={}
    for i in senders :
        l=[]
        if(i in receivers) :
            for j in receivers[i] :
                l.append(address[j])
        d[i]=l
    return d
def find_distance_price(l_of_addr,dispatch_center_addr,discount) : 
    totaldistance=0
    if(l_of_addr==[]) :
        return 0
    for i in l_of_addr :
        totaldistance+=get_distance(i,dispatch_center_addr)
    if(totaldistance<=10) :
        freight=totaldistance*2
    else :
        freight=(totaldistance-10)*3+20
    if(len(discount)==0) :
        price=freight
        return price
    else :
        decrease=0
        for i in range(totaldistance,-1,-1) :
            if i in discount :
                decrease=discount[i]
                break
    price=max(0,freight-decrease)
    return price
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  send_and_recei_addr=send_receive_addr(senders,receivers,address)
  d={}
  for i in send_and_recei_addr :
      d[i]=find_distance_price(send_and_recei_addr[i],dispatch_center_addr,discount)
  return d
def total_freight_of_everyone(d) :
    total=0
    for i in d :
        total+=d[i]
    return total
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  list_of_freight=[]
  for i in dispatch_centers :
      list_of_freight.append(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]))
  lofprice={}
  for i in dispatch_centers :
      lofprice[i]=total_freight_of_everyone(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]))
  price=[]
  for i in lofprice :
      price.append(lofprice[i])
  minimum=min(price)
  lofminimum=[]
  for i in lofprice :
      if(lofprice[i]==minimum) :
          lofminimum.append(i)
  lofminimum.sort()
  result=[lofminimum[0],minimum]
  return result

xxx213xxxx: HW9
bytecount: {'code': 696, 'const': 232, 'code+const': 928}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  an=[]
  for i in senders:
    if i in receivers:     
      for j in receivers[i]:
        if j in address:
          an.append(address[j])
  return an
def get_item_count(sending_addresses) :
  an={}
  for i in sending_addresses:
    if i in an:
      an[i]+=1
    else:
      an[i]=1
  return an
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  an={}
  for i in senders:
    dis=0
    for j in get_sending_addresses([i], receivers, address):
      dis+=get_distance(j,dispatch_center_addr)
    if dis>10:
      an[i]=20+((dis-10)*3)
    else:
      an[i]=dis*2
    a=0
    c=1
    for j in discount:
      if j>dis:
        an[i]-=a
        c=0
        break
      a=discount[j]
    if c==1:
      an[i]-=a
  for i in an:
    if an[i]<0:
      an[i]=0
  return an
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  gg=[]
  for x in dispatch_centers:
    an={}
    mo=0
    for i in senders:
      dis=0
      for j in get_sending_addresses([i], receivers, address):
        dis+=get_distance(j,dispatch_centers[x])
      if dis>10:
        an[i]=20+((dis-10)*3)
      else:
        an[i]=dis*2
      a=0
      c=1
      for j in discount:
        if j>dis:
          an[i]-=a
          c=0
          break
        a=discount[j]
      if c==1:
        an[i]-=a
    for i in an:
      if an[i]<0:
        an[i]=0
      mo+=an[i]
    gg+=[[mo,x]]
  gg.sort()
  return gg[0][::-1]

xxx038xxxx: HW9
bytecount: {'code': 746, 'const': 195, 'code+const': 941}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_distance(address1, address2):
  address1 = int(address1.strip().replace("/",""))
  address2 = int(address2.strip().replace("/",""))
  return abs(address1-address2)
def get_sending_addresses(senders, receivers, address) :
  l = []
  for sender in senders:
      if sender in receivers:
          receiver_list = receivers[sender]
          for receiver_name in receiver_list:
              l.append(address[receiver_name])
  return l
def get_item_count(sending_addresses) :
  d = {}
  for address in sending_addresses:
      if address not in d: d[address] = 1
      else: d[address] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  dl = []
  if discount == {}:
      discount[0] = 0
  for di in discount:
      dl.append(di)
  dl.sort()
  sorted_discount = {}
  for k in dl:
      sorted_discount[k] = discount[k]
  for sender in senders:
      distance = 0
      price = 0
      if sender in receivers:
          for receiver in receivers[sender]:
              distance += get_distance(address[receiver], dispatch_center_addr)
          total_discount = 0
          discount_list = []
          discount_key = list(sorted_discount.keys())[0]
          for dis in sorted_discount:
              discount_list.append(dis)
              if distance >= dis:
                  discount_key = dis
                  pass
              elif distance < dis: break
          total_discount = sorted_discount[discount_key]
          if distance < list(sorted_discount.keys())[0]:
            total_discount = 0
          if distance > 10:
              price = 20 + (distance-10)*3
          else: price = distance*2
          price = max(0, price-total_discount)
      d[sender] = price
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  l = []
  dispatch_dict = {}
  for dispatch_location in dispatch_centers:
      total_price = 0
      price_dict = calculate_fee(senders, receivers, address, discount, dispatch_centers[dispatch_location])
      for price in price_dict.values():
          total_price += price
      dispatch_dict[dispatch_location] = total_price
  price_to_compare = list(dispatch_dict.values())[0]
  dispatch_name_list = []
  for dispatch_location in dispatch_dict:
      if price_to_compare > dispatch_dict[dispatch_location]:
          price_to_compare = dispatch_dict[dispatch_location]
          dispatch_name_list.clear()
          dispatch_name_list.append(dispatch_location)
      elif price_to_compare == dispatch_dict[dispatch_location]:
          dispatch_name_list.append(dispatch_location)
  dispatch_name_list.sort()    
  list_to_return = [dispatch_name_list[0], price_to_compare]
  return list_to_return

xxx024xxxx: HW9
bytecount: {'code': 738, 'const': 212, 'code+const': 950}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  a = []
  for i in senders:
    if i in receivers:
      b = receivers[i]
      for j in b:
        if j in address:
          a.append(address[j])
  return a
def get_item_count(sending_addresses) :
  a = {}
  for i in sending_addresses:
    if i in a:
      a[i] += 1
    else :
      a[i] = 1
  return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  a ={}
  dis = []
  for i in discount:
    dis.append(i)
  dis.sort()
  for i in senders:
    s = get_sending_addresses([i], receivers, address)
    r = 0
    p = 0
    dc = 0
    if len(s) != 0:
      for j in s:
        r += get_distance(j,dispatch_center_addr)
      for k in dis:
        if r >= k:
          dc = k
      if dc in discount :
        p0 = discount[dc]
      else:
        p0 = 0
      if r > 10 :
        p = 20 + ((r-10)*3) - p0
      else:
        p = r*2 - p0
      if p < 0:
        p = 0
    a[i] = p
  return a
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  dis = []
  patch = []
  s0 = 99999999999999999999
  for i in discount:
    dis.append(i)
  dis.sort()
  for i in dispatch_centers:
    patch.append(i)
  patch.sort()
  for x in patch:
    z = []
    for i in senders:
      s = get_sending_addresses([i], receivers, address)
      r = 0
      p = 0
      dc = 0
      if len(s) != 0:
        for j in s:
          r += get_distance(j,dispatch_centers[x])
        for k in dis:
          if r >= k:
            dc = k
        if dc in discount :
          p0 = discount[dc]
        else:
          p0 = 0
        if r > 10 :
          p = 20 + ((r-10)*3) - p0
        else:
          p = r*2 - p0
        if p < 0:
          p = 0
      z.append(p)
    if sum(z) < s0:
      a = [x,sum(z)]
      s0 = sum(z)
  return a

xxx033xxxx: HW9
bytecount: {'code': 802, 'const': 148, 'code+const': 950}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  out = []
  peoplelist = []
  personlist = []
  for i in range(len(senders)):
    if senders[i] in receivers:
      peoplelist.append(receivers[senders[i]])
  for list in peoplelist:
      for people in list:
          personlist.append(people)
  for name in personlist:
    out.append(address[name])
  return out
def get_item_count(sending_addresses) :
  dict = {}
  for i in range(len(sending_addresses)):
    if sending_addresses[i] in dict:
      dict[sending_addresses[i]] += 1
    else:
      dict[sending_addresses[i]] = 1
  return dict
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  sender_distance = {}
  sender_price = {}
  for sender in senders:
    if sender in receivers:
      for receiver in receivers[sender]:
        distance = get_distance(address[receiver],dispatch_center_addr)
        if sender in sender_distance:
          sender_distance[sender] += distance
        else:
          sender_distance[sender] = distance
    else:
      sender_distance[sender] = 0
  for sender in sender_distance:
    price = 0
    distance = sender_distance[sender]
    if distance > 10:
      price += 10*2 + (distance - 10)*3
    else:
      price += distance*2
    sender_price[sender] = price
  discountlist = []
  for distance in discount:
    discountlist.append([distance,discount[distance]])
  discountlist.sort()
  discountlist = discountlist[::-1]
  for sender in sender_price:
    price = sender_price[sender]
    distance = sender_distance[sender]
    for discountdistance,discount in discountlist:
      if distance >= discountdistance:
        sender_price[sender] -= discount
        break
  for sender in sender_price:
    if sender_price[sender] < 0:
      sender_price[sender] = 0
  return sender_price
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  center_fee = {}
  for center in dispatch_centers:
    sender_price = calculate_fee(senders, receivers, address, discount, dispatch_centers[center])
    price = 0
    for sender in sender_price:
      price += sender_price[sender]
    center_fee[center] = price
  fee_center_list = []
  for center in center_fee:
    fee_center_list.append([center_fee[center],center])
  mincenter = []
  minimumfee = min(fee_center_list)[0]
  for fee,center in fee_center_list:
    if fee == minimumfee:
      mincenter.append(center)
  mincenter.sort()
  return [mincenter[0],center_fee[mincenter[0]]]

xxx200xxxx: HW9
bytecount: {'code': 814, 'const': 148, 'code+const': 962}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    true_receivers = {}
    for e in senders:
        if e in receivers:
            true_receivers[e] = receivers[e]
    Name_houses = []
    for r in true_receivers:
        for t in true_receivers[r]:
            Name_houses.append(t)
    NO_houses = []
    for e in Name_houses:
        if e in address:
            NO_houses.append(address[e])
    return NO_houses
def get_item_count(sending_addresses) :
    N_sending_addresses = {}
    for e in sending_addresses:
        if e not in N_sending_addresses:
            N_sending_addresses[e] = 1
        else:
            N_sending_addresses[e] += 1
    return N_sending_addresses
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    primary_dict = {}
    true_receivers = {}
    for e in senders:
        primary_dict[e] = 0 
        if e in receivers:
            true_receivers[e] = receivers[e]
    name_distance = {}
    for name in true_receivers:
        data = true_receivers[name]
        distance_data = []
        for ad in data:
            if ad in address:
                D = get_distance(address[ad], dispatch_center_addr)
                distance_data.append(D)
        name_distance[name] = distance_data
    list_true_receivers = []
    for K in name_distance:
        list_true_receivers.append([K,sum(name_distance[K])])
    for e in list_true_receivers:
        primary_dict[e[0]] += int(e[1])
    for e in primary_dict:
        total_distance = primary_dict[e]
        if total_distance > 0:
            if total_distance in discount:
                reducer = discount[total_distance]
            else:
                reducer = 0 
                for h in discount:
                    if total_distance > h:
                        reducer = discount[h]
            if total_distance <= 10:
                cost = total_distance*2 - reducer
                primary_dict[e] = int(cost)
            elif total_distance > 10:
                part2 = total_distance - 10
                cost = 10*2 + part2*3 - reducer
                primary_dict[e] = int(cost)
    for e in primary_dict:
        if primary_dict[e] <= 0:
            primary_dict[e] = 0
    return primary_dict
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    solution = {}
    rev_solution = {}
    for e in dispatch_centers:
        location = dispatch_centers[e]
        cost_dict = calculate_fee(senders, receivers, address, discount, location)
        price = 0
        for name in cost_dict:
            price += cost_dict[name]
        solution[e] = price
        rev_solution[price] = e
    x = min(rev_solution)
    name_of_less_cost = []
    for e in solution:
        if solution[e] == x:
            name_of_less_cost.append([e,solution[e]])
    name_of_less_cost.sort()
    return name_of_less_cost[0]

xxx035xxxx: HW9
bytecount: {'code': 828, 'const': 148, 'code+const': 976}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  new_senders =[]
  for k1 in senders:
      if k1 in receivers:
          new_senders+=receivers[k1]
  new_address = []
  for k2 in new_senders:
      if k2 in address:
          new_address+=[address[k2]]
  return new_address
def get_item_count(sending_addresses) :
  addresses = {}
  for k1 in sending_addresses:
      if k1 in addresses:
          addresses[k1] = addresses[k1]+1
      else:
          addresses[k1] = 1
  return addresses
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  dict_senders = {}
  for k1 in senders:
      if k1 in receivers:
          dict_senders[k1]=receivers[k1]
      else:
          dict_senders[k1]=0
  for k2 in dict_senders:
      if dict_senders[k2]==0:
          pass
      else:
          address_k3 = []
          for k3 in dict_senders[k2]:
              address_k3+=[address[k3]]
          dict_senders[k2]=address_k3
  for k4 in dict_senders:
      if dict_senders[k4]==0:
          pass
      else:
          distance = 0
          for k5 in dict_senders[k4]:
              distance+=get_distance(k5,dispatch_center_addr)
          dict_senders[k4]=distance
  list_discount=[]
  for i in discount:
      list_discount+=[i]
  for k6 in dict_senders:
      if dict_senders[k6]==0:
          pass
      else:
           discount1 = dict_senders[k6]
           if discount=={}:
              discount1=0 
           else:
               if min(list_discount)>discount1:
                   discount1=0
               else:
                   while discount1 not in discount: 
                       discount1-=1
                   discount1=discount[discount1]
           if dict_senders[k6]>=10:
              dict_senders[k6]=(((dict_senders[k6]-10)*3)+20)-discount1
              if dict_senders[k6]<0:
                 dict_senders[k6]=0 
           else:
               if 0<dict_senders[k6]<10:
                  dict_senders[k6]=dict_senders[k6]*2-discount1
                  if dict_senders[k6]<0:
                     dict_senders[k6]=0
  return dict_senders
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  dispatch = {}
  for k1 in dispatch_centers:
     dispatch[k1]=calculate_fee(senders, receivers, address, discount, dispatch_centers[k1])
  fee=[]
  for k2 in dispatch:
      sum_fee = 0
      for k3 in dispatch[k2]:
         sum_fee+=dispatch[k2][k3] 
      fee+=[sum_fee]
      dispatch[k2]=sum_fee
  min_fee = min(fee)
  location=[]
  for k4 in dispatch:
      if dispatch[k4]==min_fee:
          location+=[k4]
  location.sort()         
  return [location[0],min_fee]

xxx017xxxx: HW9
bytecount: {'code': 826, 'const': 162, 'code+const': 988}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    use=[]
    for e in senders:
        if e in receivers:
            for i in range(len(receivers[e])):
                use.append(address[receivers[e][i]])
    return use
def get_item_count(sending_addresses):
    se={}
    for i in range(len(sending_addresses)):
        if sending_addresses[i] in se:
            se[sending_addresses[i]]+=1
        else:
            se[sending_addresses[i]]=1
    return se
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    use={}
    for i in range(len(senders)):
        if senders[i] in receivers:
            add=[]
            name=receivers[senders[i]]
            for e in range(len(name)):
                add.append(address[name[e]])
            distance=0
            for a in range(len(add)):
                distance+=get_distance(add[a], dispatch_center_addr)
            money=0
            if distance<=10:
                money+=(distance*2)
            else:
                money+=(10*2)+((distance-10)*3)
            dis=0        
            x=[]
            for e in discount:
                x.append(e)
            for o in range(len(x)-1):
                if x[o]>=distance:
                    dis+=discount[x[o]]
                    break
                elif x[o]<distance<=x[o+1]:
                    dis+=discount[x[o]]
                    break
                elif o+2==len(discount):
                    dis+=discount[x[o+1]]
                    break
            real=money-dis
            if real<0:
                real+=-(money-dis)
            use[senders[i]]=real
        else:
            use[senders[i]]=0
    return use
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    notuse=[]
    for e in dispatch_centers:
        use=calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        num=0
        for i in use:
            num+=use[i]
        x=[e,num]
        notuse.append(x)
    notuse.sort()
    realuse=notuse[0]
    for i in range (1,len(notuse)):
        if realuse[1]>notuse[i][1]:
            realuse=notuse[i]
        elif realuse[1]==notuse[i]:
            realuse.append(notuse[i])
    return realuse

xxx200xxxx: HW9
bytecount: {'code': 774, 'const': 215, 'code+const': 989}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  b = []
  for i in range(len(senders)):
    if senders[i] in receivers:
      a = receivers[senders[i]]
      for i in range(len(a)):
        b.append(address[a[i]])
    else:
      pass
  return b
def get_item_count(sending_addresses) :
  a = {}
  for i in range(len(sending_addresses)):
    if sending_addresses[i] not in a:
      a[sending_addresses[i]] = 1
    else:
      a[sending_addresses[i]] += 1
  return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  a = {}
  for e in senders:
    if e in receivers:
      d = 0
      baht = 0
      n = receivers[e]
      for i in range(len(n)):
        d += get_distance(address[n[i]],dispatch_center_addr)
      dis = []
      for j in discount:
        if d >= j:
          dis.append(discount[j])
      if d > 10:
        baht = 10*2+((d-10)*3)
      else: 
        baht += d*2
      if dis != []:
        baht = baht - dis[-1]
      if baht <= 0:
        a[e] = 0
      else:
        a[e] = baht
    else:
      a[e] = 0
  return a
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  a = []
  b = ''
  c = ['']
  lo = []
  ans = []
  for e in dispatch_centers:
    k = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
    f = 0
    for j in k:
      f += k[j]
    a.append(f)
    lo.append(e)
  check = True
  for i in range(1,len(a)):
    if a[i-1] == a[i]:
      check = True
    else:
      check = False
      break
  if check == True:
    lo.sort()
    ans.append(lo[0])
    ans.append(a[0])
    return ans
  else:
    for i in range(1,len(a)):
      if a[i-1] <= a[i]:
        c[0] = a[i-1]
        b = i-1
      else:
        c[0] = a[i]
        b = i
    ans.append(lo[b])
    ans.append(c[0])
    return ans

xxx037xxxx: HW9
bytecount: {'code': 810, 'const': 246, 'code+const': 1056}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  addSent = [] 
  for e in senders:
      if e in receivers:
          for j in receivers[e]:
              if j in address:
                  addSent.append(address[j])
  return addSent
def get_item_count(sending_addresses) :
  toItem = {} 
  for e in sending_addresses:
      if e not in toItem:
          toItem[e] = 1 
      else:
          toItem.update({e:toItem[e]+1}) 
  return toItem
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  realSender = {} 
  dscList = [] 
  for d in discount:
      dscList.append(d)
  dscList.sort()
  for e in senders: 
      if e in receivers:
          distances = 0 
          toPay = 0 
          for j in receivers[e]: 
              distances += get_distance(address[j],dispatch_center_addr) 
          for k in dscList: 
              if distances < k: 
                  dscPointer = dscList.index(k) 
                  if dscPointer != 0:
                      toPay -= discount[dscList[dscPointer-1]] 
                  break
              elif k == dscList[-1]:
                  toPay -= discount[dscList[-1]] 
          if distances <= 10: 
              toPay += distances*2
          else: 
              toPay += (distances-10)*3 + 20
          if toPay < 0:
              toPay = 0
          realSender.update({e:toPay}) 
      else:
          realSender.update({e:0}) 
  return realSender
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ctrList = [] 
  dscList = [] 
  for d in discount:
      dscList.append(d)  
  dscList.sort()
  for ctrName in dispatch_centers: 
      ctrLocation = dispatch_centers[ctrName]
      ctrSum = 0
      for e in senders: 
          if e in receivers:
              toPay = 0
              distances = 0 
              dsc = 0 
              for j in receivers[e]: 
                  distances += get_distance(address[j],ctrLocation) 
              for k in dscList: 
                  if distances < k: 
                      dscPointer = dscList.index(k) 
                      if dscPointer != 0:
                          dsc = discount[dscList[dscPointer-1]] 
                      break
                  elif k == dscList[-1]:
                      dsc = discount[dscList[-1]]
              if distances <= 10: 
                  toPay += distances*2
              else: 
                  toPay += (distances-10)*3 + 20
              toPay -= dsc
              if toPay >= 0:
                  ctrSum += toPay
      ctrList.append([ctrSum,ctrName]) 
  ctrList.sort()
  return [e for e in ctrList[0]][::-1]

xxx021xxxx: HW9
bytecount: {'code': 900, 'const': 160, 'code+const': 1060}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    a = []
    q = []
    for e in senders:
        for i in receivers:
            if e == i:
                a.append(receivers[e])
    for i in a:
        for b in i:
             for x in address:
                  if b == x:
                      q.append(address[b])
    return q
def get_item_count(sending_addresses) :
    a = {}
    for e in sending_addresses:
        a[e] = 0
    for i in a:
        for k in sending_addresses:
            if i == k:
                a[i] += 1
    return a
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    a = {}
    b = []
    c = {}
    u = {}
    for i in senders:
        u[i] = None
    for i in senders:
        a[i] = 0
    for i in senders:
        if i not in receivers:
            c[i] = []
            continue
        x = len(receivers[i])
        for e in address:
            for q in range(x):
                if receivers[i][q] == e:
                    b.append(address[e])
            c[i] = b
        b = []
    for i in c:
        y = 0
        x = len(c[i])
        for e in range(x):
            y += get_distance(c[i][e], dispatch_center_addr)
        a[i] = y
    for i in a:
        for e in sorted(discount.keys()):
            if a[i] >= e:
                if a[i] > 10:
                    if (a[i]-10)*3 + 20 - discount[e] < 0:
                        u[i] = 0
                    else:
                        u[i] = (a[i]-10)*3 + 20 - discount[e]
                else:
                    if (a[i])*2 - discount[e] < 0:
                        u[i] = 0
                    else:
                        u[i] = (a[i])*2 - discount[e]
        if u[i] is None:
            if a[i] > 10:
                u[i] = (a[i]-10)*3 + 20 
            else:
                u[i] = (a[i])*2 
    return u
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    a = []
    x = {}
    for e in dispatch_centers:
        x = calculate_fee(senders, receivers, address, discount, dispatch_centers[e])
        b = 0
        for key in x:
            b += x[key]
        a.append([b,e])
    a.sort()
    return a[0][::-1]

xxx216xxxx: HW9
bytecount: {'code': 880, 'const': 192, 'code+const': 1072}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    rn=[] 
    ra=[] 
    for e in senders:
        if e in receivers:
            for p in receivers[e]:
                rn.append(p)
    for key in rn:
        ra.append(address[key])
    return ra
def get_item_count(sending_addresses) :
    na={} 
    for key in sending_addresses:
        if key in na:
            na[key]+=1
        else:
            na[key]=1
    return na
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    ps={} 
    ds={} 
    pd={} 
    for name in senders:
        ps[name]=0
        ds[name]=0
        pd[name]=0
    for name in senders:
        if name in receivers: 
            for p in receivers[name]:
                ds[name]+=get_distance(address[p],dispatch_center_addr)
    for key in ds:
        if ds[key]<=10:
            ps[key]+=2*ds[key]
        else:
            ps[key]+=20+3*(ds[key]-10)
    l=[] 
    for k in discount:
        l.append([k,discount[k]])
    l.append([0,0])
    l.append([1000000000,1000000000])
    l.sort()
    for key in ds:
        for i in range(len(l)):
            if l[i][0]>ds[key]:
                ps[key]-=l[i-1][1]
                break
    for key in ps:
        if ps[key]<0:
            ps[key]=0
    return ps
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    l=[]
    for key in dispatch_centers:
        l.append([key,dispatch_centers[key]])
    preout=[]
    for e in l:
        sum=0
        ps=calculate_fee(senders,receivers,address,                   discount,e[1])
        for k in ps:
            sum+=ps[k]
        preout.append([sum,e[0]])
    preout.sort()
    out=[preout[0][1]]
    for j in range(len(preout)-1):
        if preout[j]==preout[j+1]:
            out.append(preout[j+1][1])
    out.sort()
    where=out[0]
    for z in range(len(preout)):
        if preout[z][1]==where:
            return preout[z][-1::-1]

xxx037xxxx: HW9
bytecount: {'code': 900, 'const': 174, 'code+const': 1074}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  name = []
  for key in receivers:
      for i in range(len(senders)):
          if senders[i] == key:
              for j in range(len(receivers[key])):
                  name.append(receivers[key][j])
  a = []
  for keyy in address:
      for k in range(len(name)):
          if name[k] == keyy:
              a.append(address[keyy])
  return a
def get_item_count(sending_addresses) :
  d = {}
  n_sa = []
  for i in range(len(sending_addresses)):
      if sending_addresses[i] not in n_sa:
          n_sa.append(sending_addresses[i])
  for k in range(len(n_sa)):
      d[n_sa[k]] = 0
  for key in d:
      for j in range(len(sending_addresses)):
          if key == sending_addresses[j]:
              d[key] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  dis = {}
  for key in senders:
      d[key] = 0
      dis[key] = 0
      if key in receivers:
          for i in range(len(receivers[key])):
              d[key] += get_distance(address[receivers[key][i]], dispatch_center_addr)
              dis[key] += get_distance(address[receivers[key][i]], dispatch_center_addr)
  c = 0
  for keyy in d:
      if d[keyy] > 10:
          d[keyy] = 10*2 + 3*(d[keyy]-10)
      else:
          if d[keyy] == 0:
              d[keyy] = 0
          else:
              d[keyy] = 2*d[keyy]
      for r in dis:
          for e in discount:
              if dis[keyy] >= e:
                  c = int(discount[e])
      d[keyy] = int(d[keyy])-int(c)
      if d[keyy] < 0:
          d[keyy] = 0       
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  ad = []
  dd = {}
  for key in dispatch_centers:
      d = calculate_fee(senders, receivers, address, discount, dispatch_centers[key])
      for e in d:
          ad.append([key, [e, d[e]]])
      dd[key] = 0
      for i in ad:
          if i[0] == key:
              dd[key] += i[1][1]
  l = []
  for k in dd:
      l.append([dd[k], k])
  l.sort()
  ans = l[0][::-1]
  return ans

xxx035xxxx: HW9
bytecount: {'code': 760, 'const': 316, 'code+const': 1076}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
    sending_addresses = []
    [sending_addresses.extend(k) for k in [[address[j] for j in receivers[i] if address.get(j)] for i in senders if receivers.get(i)]]
    return sending_addresses
def get_item_count(sending_addresses) :
    item_count = dict([(i, 0) for i in sending_addresses])
    [item_count.update({i: (item_count[i] + 1)}) for i in sending_addresses]
    return item_count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
    sorted_discount_key = sorted(list(discount.keys()) + [-1], reverse=True)
    total_distance = [sum([get_distance(address.get(j), dispatch_center_addr) if j != [] else 0 for j in receivers.get(i, [[]])]) for i in senders]
    discount_list = [discount.get(sorted_discount_key[j], 0) for j in [sorted([i] + sorted_discount_key, reverse=True).index(i) for i in total_distance]]
    fee_list = [3 * i - 10 if i > 10 else 2 * i for i in total_distance]
    return dict([(senders[i], fee_list[i] - discount_list[i]) if fee_list[i] - discount_list[i] >= 0 else (senders[i], 0) for i in range(len(senders))])
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
    return sorted(sorted([[i, sum(calculate_fee(senders, receivers, address, discount, dispatch_centers[i]).values())] for i in dispatch_centers]), key=lambda x: x[1])[0]

xxx043xxxx: HW9
bytecount: {'code': 958, 'const': 190, 'code+const': 1148}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  senders_confirm = []
  recievers_confirm = []
  recievers_ad = []
  for i in senders:
    if i not in receivers.keys():
      continue
    else:
      senders_confirm.append(i)
  for i in senders_confirm:
    for j in receivers[i]:
      recievers_confirm.append(j)
  for i in recievers_confirm:
    recievers_ad.append(address[i])
  return recievers_ad
def get_item_count(sending_addresses) :
  d = dict()
  for i in sending_addresses:
    if i not in d.keys():
      d[i] = 1
    elif i in d.keys():
      d[i] += 1
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  senders_confirm = []
  discount_list = [list(i) for i in discount.items()]
  d = {i:0 for i in senders}
  for i in senders:
    if i not in receivers.keys():
      continue
    else:
      senders_confirm.append(i)
  for i in senders_confirm:
    receivers_confirm = []
    receivers_ad = []
    distance = 0
    for j in receivers[i]:
      if j not in receivers_confirm:
        receivers_confirm.append(j)
      else: continue  
    for k in receivers_confirm:
      receivers_ad.append(address[k])
    for ad in receivers_ad:
      distance += get_distance(ad,dispatch_center_addr)
    if distance <= 10 : 
      d[i] += distance * 2
    elif distance > 10 :
      d[i] += 20
      d[i] += (distance-10) * 3
    disc_w_dist = [i for i in discount.keys()]
    disc_w_dist.append(distance)
    dis_index = [i for i in range(len(disc_w_dist)) if sorted(disc_w_dist)[i] == distance][-1]
    if dis_index == 0 : continue
    elif discount_list[dis_index-1][1] <= d[i]:
      d[i] -= discount_list[dis_index-1][1]
    elif discount_list[dis_index-1][1] > d[i]:
      d[i] = 0
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  fee_list = []
  for k in dispatch_centers.keys():
    sum = 0
    fee = calculate_fee(senders, receivers, address, discount, dispatch_centers[k])
    for i in fee.values():
      sum += i
    fee_list.append([k,sum])
  min_fee = []
  min = 99999999
  for x,y in fee_list:
    if y < min: min = y
    else: continue
  for x,y in fee_list:
    if y == min : min_fee.append([x,y])
    else: continue
  return sorted(min_fee)[0]

xxx017xxxx: HW9
bytecount: {'code': 968, 'const': 237, 'code+const': 1205}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_distance(address1, address2):
  address1 = int(address1.strip().replace("/",""))
  address2 = int(address2.strip().replace("/",""))
  return abs(address1-address2)
def get_sending_addresses(senders, receivers, address) :
  get_name = []
  for e in senders:
      if e in receivers:
          for i in range(len(receivers[e])):
              get_name.append(receivers[e][i])
  ans = []
  for ch in get_name:
      if ch in address:
          ans.append(address[ch])
  return ans
def get_item_count(sending_addresses) :
  ans = {}
  for num in sending_addresses:
      if num not in ans:
          ans[num] = 1
      else :
          ans[num] += 1
  return ans
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  send = {}
  dis = {}
  for ch in senders:
      info = get_sending_addresses([ch], receivers, address)
      send[ch] = info
      dis[ch] = 0
  for key in send:
      if send[key] == []:
          dis[key] = 0
      elif len(send[key]) == 1:
          send[key].append(dispatch_center_addr)
          dis[key] += get_distance(send[key][0],send[key][1])
      else:
          for z in send[key]:
                dis[key] += get_distance(z,dispatch_center_addr)
  cost = {}
  for key2 in dis:
      if dis[key2] <= 10:
          cost[key2] = dis[key2]*2
      else:
          dis[key2] -= 10
          cost[key2] = 20+(dis[key2]*3)
          dis[key2] += 10
  new_discount = []
  for new in discount:
      new_discount.append([new,discount[new]])
  for key3 in dis:
      for e in range(len(new_discount)-1):
          if new_discount[e][0] <= dis[key3] <= new_discount[e+1][0]:
              cost[key3] -= new_discount[e][1]
          elif dis[key3] >= new_discount[-1][0]:
                cost[key3] -= new_discount[-1][1]
                break
          else: pass
  for check in cost:
      if cost[check] < 0:
          cost[check] = 0
  return cost
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  d_cost = {}
  for keys in dispatch_centers:
      d_cost[keys] = calculate_fee(senders, receivers, address, discount, dispatch_centers[keys])
  total = []
  s = 0
  for ch in d_cost:
      for cost in d_cost[ch]:
          s += d_cost[ch][cost]
      total.append([s,ch])
      s = 0
  total.sort()
  return min(total)[::-1]

xxx018xxxx: HW9
bytecount: {'code': 1022, 'const': 186, 'code+const': 1208}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  reciever_ = []
  for i in senders:
      if i in receivers:
          for j in receivers[i]:
              reciever_.append(j)
  address_ =[]
  for t in reciever_:
      if t in address:
          address_.append(address[t])
  return address_
def get_item_count(sending_addresses) :
  count = {}
  for t in sending_addresses:
      count[t] = 0
  for h in sending_addresses:
      if h in count:
          count[h] += 1
  return count
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  home_to_dis = {}
  for i in address:
      home_to_dis[i] = get_distance(address[i],dispatch_center_addr)
  sender2receivers = {}
  for sender in senders:
      sender2receivers[sender] = 0
  for r in receivers:
      for e in receivers[r]:
          if r in senders:
              sender2receivers[r] += home_to_dis[e]
          else:
              sender2receivers[r] = 0
  price_before_dis = {}
  for _ in sender2receivers:
      price_before_dis[_] = sender2receivers[_]
  for se in sender2receivers:
      if sender2receivers[se] <= 10:
          price_before_dis[se] = sender2receivers[se]*2
      else:
          price_before_dis[se] = 10*2 + (sender2receivers[se]-10)*3
  dis2count = []
  dis2count_ = {}
  for u in sender2receivers:
      for d in discount:
          dis2count.append([sender2receivers[u] - int(d),int(d)])
      dis2count_[u] = dis2count
      dis2count = []
  comp_ = ' '
  disc_distance = {}
  for _d in dis2count_:
      if len(dis2count_[_d]) != 0:
          dis2count_[_d].sort()
      else:
          dis2count_[_d] = [[0,0]]
      for j in dis2count_[_d]:
          if j[0] < 0:
              continue
          else:
              comp_ = j[1]
              break
      disc_distance[_d] = comp_
      comp_ = ' '
  discount2dis = {}
  for hp in disc_distance:
      if disc_distance[hp] in discount:
          discount2dis[hp] = discount[disc_distance[hp]]
      else:
          discount2dis[hp] = 0
  price_after_dis = {}
  for sen in price_before_dis:
      if (price_before_dis[sen] - discount2dis[sen]) < 0:
          price_after_dis[sen] = 0
      else:
          price_after_dis[sen] = (price_before_dis[sen] - discount2dis[sen])
  price_after_dis_ = {}
  for h in price_after_dis:
      if h in senders:
          price_after_dis_[h] = (price_after_dis[h])
  return price_after_dis_
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  prices_2_best_list = {}
  for dispatch_center_addr in dispatch_centers:
      prices_2_best_list[dispatch_center_addr] = calculate_fee(senders, receivers, address, discount, dispatch_centers[dispatch_center_addr])
  prices_2_best = {}
  prices_2_best_num = []
  for addr in prices_2_best_list:
      for p in prices_2_best_list[addr]:
          prices_2_best_num.append(prices_2_best_list[addr][p])
      prices_2_best[addr] = sum(prices_2_best_num)
      prices_2_best_num = []
  price_2_for_sort = []
  for u in prices_2_best:
      price_2_for_sort.append([prices_2_best[u],u])
  price_2_for_sort.sort()
  if len(price_2_for_sort) != 0:
        best_location = price_2_for_sort[0]
  else:
      best_location = price_2_for_sort
  best_location.reverse()
  return best_location

xxx034xxxx: HW9
bytecount: {'code': 1014, 'const': 246, 'code+const': 1260}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  x = []
  z = []
  for i in senders:
    if i in receivers:
      x += receivers[i]
  for i in x:
    if i in address:
      z.append(address[i])
  z.sort()
  return z
def get_item_count(sending_addresses) :
  d = {}
  a = []
  b = []
  for i in sending_addresses:
    if i not in a:
      a.append(i)
      b.append(1)
    else:
      k = a.index(i)
      b[k] += 1
  for i in range(len(a)):
    d.update({a[i] : b[i]})
  return d
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  d = {}
  a = []
  b = []
  for i in discount:
    a.append(i)
    b.append(discount[i])
  for i in senders:
    distance = 0
    money = 0
    if i in receivers:
      for j in receivers[i]:
        distance += get_distance(address[j], dispatch_center_addr)
      if distance <= 10:
        money = distance * 2
      else:
        money = 20 + ((distance-10)*3)
      for j in a:
        if j == distance:
          k = a.index(j)
          money -= b[k]
          break
        elif j > distance:
          k = a.index(j)-1
          if k != -1:
            money -= b[k]
          break
        elif j == a[-1]:
          money -= b[-1]
      if money < 0:
        money = 0
    d[i] = money
  return d
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  d = {}
  r = []
  a = []
  b = []
  h = []
  for i in discount:
    a.append(i)
    b.append(discount[i])
  for i in senders:
    q = get_sending_addresses([i], receivers, address)
    r.append(q)
  for p in dispatch_centers:
    x = []
    for i in r:
      o = 0
      for j in range(len(i)):
        o += get_distance(i[j], dispatch_centers[p])
      x.append(o)
    d[p] = x
  for i in d:
    all_money = 0
    for j in d[i]:
      if j <= 10:
          money = j * 2
      else:
          money = 20 + ((j-10)*3)
      for y in a:
        if y == j:
          k = a.index(y)
          money -= b[k]
          break
        elif y > j:
          k = a.index(y)-1
          if k != -1:
            money -= b[k]
          break
        elif y == a[-1]:
          money -= b[-1]
      if money < 0:
        money = 0
      all_money += money
    f = [all_money,i]
    h.append(f)
  h.sort()
  return h[0][::-1]

xxx037xxxx: HW9
bytecount: {'code': 1448, 'const': 190, 'code+const': 1638}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  ref = []
  for i in range(len(senders)):
      if senders[i] in receivers:
          for j in range(len(receivers[senders[i]])):
              ref.append(receivers[senders[i]][j])
      else: pass
  ans=[]
  for i in range(len(ref)):
      if ref[i] in address:
          ans.append(address[ref[i]])
  return ans
def get_item_count(sending_addresses) :
  r = dict()
  for i in range(len(sending_addresses)):
      if sending_addresses[i] not in r:
          r[sending_addresses[i]] = 1
      else:
          r[sending_addresses[i]] +=1
  return r
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  km = dict()
  for i in range(len(senders)):
      if senders[i] in receivers:
          for j in range(len(receivers[senders[i]])): 
              ff = get_distance(address[receivers[senders[i]][j]],dispatch_center_addr)
              if senders[i] not in km:
                  km[senders[i]] = ff
              else:
                  km[senders[i]] += ff
  for i in range(len(senders)):
      if senders[i] not in km:
          km[senders[i]] = 0
      else: pass
  fee = dict()
  for i in range(len(senders)):
      if km[senders[i]] <=10:
          fee[senders[i]] = km[senders[i]] * 2
      else:
          kmreal = km[senders[i]]-10
          fee[senders[i]] = (10*2) + kmreal*3
  dictdis = dict()     
  for i in range(len(senders)):
      disbath = 0
      for kmm in discount:
          if km[senders[i]] >= kmm:
              disbath = discount[kmm]
      dictdis[senders[i]] = disbath       
  ansdic = dict()
  for i in range(len(senders)):
      if fee[senders[i]] - dictdis[senders[i]] >= 0:
          ansdic[senders[i]] = fee[senders[i]] - dictdis[senders[i]]
      else:
          ansdic[senders[i]] = 0
  return ansdic
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  dispatchh = dict()
  for centers in dispatch_centers: 
      km = dict()
      for i in range(len(senders)):
          if senders[i] in receivers:
              for j in range(len(receivers[senders[i]])): 
                  ff = get_distance(address[receivers[senders[i]][j]],dispatch_centers[centers])
                  if senders[i] not in km:
                      km[senders[i]] = ff
                  else:
                      km[senders[i]] += ff
      for i in range(len(senders)):
          if senders[i] not in km:
              km[senders[i]] = 0
          else: pass
      fee = dict()
      for i in range(len(senders)):
          if km[senders[i]] <=10:
              fee[senders[i]] = km[senders[i]] * 2
          else:
              kmreal = km[senders[i]]-10
              fee[senders[i]] = (10*2) + kmreal*3
      dictdis = dict()     
      for i in range(len(senders)):
          disbath = 0
          for kmm in discount:
              if km[senders[i]] >= kmm:
                  disbath = discount[kmm]
          dictdis[senders[i]] = disbath       
      ansdic = dict()
      for i in range(len(senders)):
        if fee[senders[i]] - dictdis[senders[i]] >= 0:
            ansdic[senders[i]] = fee[senders[i]] - dictdis[senders[i]]
        else:
            ansdic[senders[i]] = 0
      totalfee = 0
      for name in ansdic:
          totalfee += ansdic[name]
      dispatchh[centers] = totalfee
  anslist = []
  des = dict()
  for namee in dispatchh:
      des[dispatchh[namee]] = namee
  nameofmin = []
  minfee = min(des)
  for diss in dispatchh:
      if dispatchh[diss] == minfee:
          nameofmin.append(diss)
  nameofmin.sort()
  anslist.append(nameofmin[0])
  anslist.append(minfee)
  return anslist

xxx150xxxx: HW9
bytecount: {'code': 936, 'const': 890, 'code+const': 1826}
check_import({'allowable': ['math']}): none
check_LTSD({'LTSD': 'S'}): none
def get_sending_addresses(senders, receivers, address) :
  addresses = list()
  for sender in senders:
    if(receivers.get(sender,-1) != -1):
      for receiver in receivers[sender]:
        if(address.get(receiver,-1) != -1):
            addresses.append(address[receiver])
  return addresses
def get_item_count(sending_addresses) :
  counted = dict()
  for address in sending_addresses: 
    if(counted.get(address,-1) != -1) : continue
    else :
      counted[address] = sending_addresses.count(address)
  return counted
def calculate_fee(senders, receivers, address, discount, dispatch_center_addr) :
  center_addr = dispatch_center_addr
  cost_per_sender = dict()
  for sender in senders:
    person = sender
    sd = list()
    sd.append(person)
    addresses = get_sending_addresses(sd, receivers, address)  
    counted = get_item_count(addresses) 
    if(len(addresses) == 0): cost_per_sender[person] = 0
    total_distance = 0
    for ad in addresses:
      total_distance += (get_distance(center_addr, ad))*counted[ad]
    total_cost = 0
    if(total_distance <= 10): total_cost = total_distance*2
    else : total_cost = 10*2 + (total_distance-10)*3
    at_least_discount = 0;
    if(discount.get(total_distance, -1) != -1):
        at_least_discount = discount[total_distance]
    else:
      for dist,value in discount.items() :
          if(dist < total_distance):
            at_least_discount = value
          elif( dist > total_distance ):
            break;
    if(at_least_discount > total_cost):
      cost_per_sender[person] = 0
    else:
      cost_per_sender[person] = total_cost-at_least_discount
  return cost_per_sender
def find_best_location(senders, receivers, address, discount , dispatch_centers) :
  find_location = list()
  for location, addr in dispatch_centers.items():
    all_order = calculate_fee(senders, receivers, address, discount, addr)
    cost_per_location = sum(value for value in all_order.values())
    find_location.append([cost_per_location, location])
  find_location.sort()
  if(len(find_location) == 0):
    return []
  return find_location[0][::-1]
def main() :
  print(get_sending_addresses(['เจเจ','โมบิว'], {'เจเจ' : ['โมบิว','เอแคลร์'], 'เอแคลร์': ['กู๊ด']}, {'เจเจ' : '00/001' , 'โมบิว' : '00/011', 'เอแคลร์': '00/015', 'กู๊ด': '00/005'}))
  print(get_item_count(['10/000', '00/001', '00/011', '00/011', '00/009']) )
  senders = ['โมบิว','เอแคลร์','เจเจ']
  receivers = {'เจเจ' : ['โมบิว','เอแคลร์'], 'เอแคลร์': ['กู๊ด']}
  address = {'เจเจ' : '00/001' ,'โมบิว' : '00/011','กู๊ด':'00/005' ,'เอแคลร์': '00/015'}
  discount = {1: 0 , 3: 9, 4: 10, 8: 7}
  dispatch_center_addr = '00/000'
  print(calculate_fee(senders, receivers, address, discount, dispatch_center_addr))
  senders = ['โมบิว','เอแคลร์','เจเจ']
  receivers = {'เจเจ' : ['โมบิว','เอแคลร์'], 'เอแคลร์': ['กู๊ด']}
  address = {'เจเจ' : '00/001' ,'โมบิว' : '00/011','กู๊ด':'00/005' ,'เอแคลร์': '00/015'}
  discount = {1: 0 , 3: 9, 4: 10, 8: 7}
  dispatch_centers = {'สาธร' : '00/000', 'ร่วมฤดี' : '00/006'}
  print(find_best_location(senders, receivers, address, discount , dispatch_centers))
  senders = ['โมบิว','เอแคลร์']
  receiver = {'เจเจ' : ['โมบิว','เอแคลร์'], 'เอแคลร์': ['กู๊ด']}
  address = {'เจเจ' : '00/001' ,'โมบิว' : '00/011','กู๊ด':'00/005' ,'เอแคลร์': '00/015'}
  discount = {1: 0 , 3: 9, 4: 10, 8: 7}
  dispatch_centers = {'สาธร' : '00/000', 'ร่วมฤดี' : '00/006'}
  print(find_best_location(senders, receivers, address, discount , dispatch_centers))