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