all (407)
# 6030048821 (29.34) 1 (2021-03-29 18:17)

def approx_match(stations, name):
    out = []
    for k in stations:
        if checkword(name,k):
            out.append(k)
    return out
def top_k_min_temp_stations(stations, K):
    return sorted(stations,key=lambda s:stations[s]['temp'])[:K]
def top_k_max_temp_stations(stations, K):
    return sorted(stations,key=lambda s:-stations[s]['temp'])[:K]
def peak_stations(stations):
    return [min(stations,key=lambda s:stations[s]['lat']),\
            max(stations,key=lambda s:stations[s]['lat']),\
            min(stations,key=lambda s:stations[s]['long']),\
            max(stations,key=lambda s:stations[s]['long'])]
def k_nearby_stations(stations, main_station, K):
    for k in stations.keys():
        if k == main_station:
            stations[k]['diff'] = 1e9
        else:
            stations[k]['diff'] = distance(stations[k]['lat'],\
                                           stations[k]['long'],\
                                           stations[main_station]['lat'],\
                                           stations[main_station]['long'])
    return sorted(stations,key=lambda s:stations[s]['diff'])[:K]
def average_temp(stations, names):
    sum_temp = 0
    for c in names:
        sum_temp += stations[c]['temp']
    return sum_temp/len(names)


# --------------------------------------------------
def checkword(chk,word):
    chk = [e.lower() for e in chk.strip().split()]
    x = 0
    s = word.lower()
    flag = True
    for c in chk:
        if c == ' ':continue
        t = s.find(c)
        if t == -1: flag = False
        else:
            x = t
            s = s[x-1:]

    return flag
# 6030182121 (20.01) 2 (2021-03-29 22:55)

def approx_match(stations, name):
    date_time, names_in_region, stations = read_weather_data()
    station = []
    name_s = name.strip().split()
    finalname = ''
    interesting_stations = []
    for i in stations:
        station.append(i.upper())
    for e in range(len(name_s)):
        finalname += name_s[e].upper()
    for k in range(len(station)):
        if finalname in station[k]:
            interesting_stations.append(station[k])
    return interesting_stations
def top_k_min_temp_stations(stations, K):
    newa = len(list(stations))
    temperature = []
    mintemp = []
    d = {}
    for i in range(newa):
        station = list(stations)[i]
        temperature.append(str(stations[station]['temp']))
        d[temperature[i]] = station
    for e in range(len(d)):
        newtemp = sorted(temperature)
        mintemp.append(str(d[newtemp[e]]))
    return mintemp[0:K]
def top_k_max_temp_stations(stations, K):
    newa = len(list(stations))
    temperature = []
    maxtemp = []
    d = {}
    for i in range(newa):
        station = list(stations)[i]
        temperature.append(str(stations[station]['temp']))
        d[temperature[i]] = station
    for e in range(len(d)):
        newtemp = sorted(temperature)
        maxtemp.append(str(d[newtemp[e]]))
    maxtemp2 = maxtemp[::-1]
    return maxtemp2[0:K]
def peak_stations(stations):
    newb = len(list(stations))
    lattitude = []
    longtitude = []
    newlat = []
    newlong = []
    peak = []
    dt = {}
    dic = {}
    for s in range(newb):
        station = list(stations)[s]
        lattitude.append(str(stations[station]['lat']))
        longtitude.append(str(stations[station]['long']))
        dt[lattitude[s]] = station
        dic[longtitude[s]] = station
    for e in range(len(dt)):
        newlat.append(float(lattitude[e]))
        newlong.append(float(longtitude[e]))
    newlat2 = str(min(newlat))
    newlat3 = str(max(newlat))
    peak.append(str(dt[newlat2]))
    peak.append(str(dt[newlat3]))
    newlong2 = str(min(newlong))
    newlong3 = str(max(newlong))
    peak.append(str(dic[newlong2]))
    peak.append(str(dic[newlong3]))
    return peak
def k_nearby_stations(stations, main_station, K):
    new = len(stations)
    lattitude = []
    longtitude = []
    d = {}
    dic = {}
    main_stations = []
    near = []
    nearest = []
    nearest_stations = []
    for j in stations:
        main_stations.append(j.upper())
    for e in range(new):
        station = list(stations)[e]
        lattitude.append(str(stations[station]['lat']))
        longtitude.append(str(stations[station]['long']))
        d[station] = lattitude[e]
        dic[station] = longtitude[e]
    if main_station in main_stations:
        main_stations.remove(main_station)
    for i in range(len(main_stations)):
        lat1 = float(d[main_station])
        lat2 = float(d[main_stations[i]])
        long1 = float(dic[main_station])
        long2 = float(dic[main_stations[i]])
        nearby = distance(lat1,long1,lat2,long2)
        near.append(nearby)
    for c in range(len(near)):
        nearest.append(float(near[c]))
    near_dis = sorted(nearest)
    for b in range(K):
        inx = nearest.index(near_dis[b])
        nearest_stations.append(main_stations[inx])
    return nearest_stations
def average_temp(stations, names):
    sumtemp = 0
    for i in range(len(names)):
        temperature = stations[names[i]]['temp']
        sumtemp += float(temperature)
        avgtemp = sumtemp/len(names)
    return avgtemp

# --------------------------------------------------
# 6030239321 (0) 3 (2021-03-29 11:05)

# 6030380021 (30) 4 (2021-03-29 23:42)

def approx_match(stations, name):
    list = []
    name = name.upper()
    N = ""
    for i in name:
        if i in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
            N += i
    for i in stations:
        if N in i:
            list.append(i)
    return(list)
def top_k_min_temp_stations(stations, K):
    list = []
    b = dict(sorted(stations.items()))
    for idx, i in enumerate(sorted(b.items(), key=lambda e: e[1]['temp'], reverse=False)):
        list.append(i[0])
    list = list[:K]
    return list
def top_k_max_temp_stations(stations, K):
    list = []
    b = dict(sorted(stations.items()))
    for idx, i in enumerate(sorted(b.items(), key=lambda e: e[1]['temp'], reverse=True)):
        list.append(i[0])
        list = list[:K]
    return list
def peak_stations(stations):
    ls = []
    a = dict(sorted(stations.items()))
    for idx, i in enumerate(sorted(a.items(), key=lambda e: e[1]['lat'])):
        if idx == 1:
            break
        ls.append(i[0])
    for idx, i in enumerate(sorted(a.items(), key=lambda e: e[1]['lat'], reverse=True)):
        if idx == 1:
            break
        ls.append(i[0])
    for idx, i in enumerate(sorted(a.items(), key=lambda e: e[1]['long'])):
        if idx == 1:
            break
        ls.append(i[0])
    for idx, i in enumerate(sorted(a.items(), key=lambda e: e[1]['long'], reverse=True)):
        if idx == 1:
            break
        ls.append(i[0])
    return ls
def k_nearby_stations(stations, main_station, K):
    ls = {}
    for i in stations:
        if i != main_station:
            dis = distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long'])
            ls[i] = dis
    a = dict(sorted(ls.items()))
    out = []
    for idx, i in enumerate(sorted(a.items(), key=lambda e: e[1])):
        if idx == K:
            break
        out.append(i[0])
    return out
def average_temp(stations, names):
    sum = 0
    for e in names:
        sum += stations[e]['temp']
    average = sum/len(names)
    return average


# --------------------------------------------------
# 6030924521 (28.74) 5 (2021-03-28 18:09)

def approx_match(stations, name):
  list_stations = list(stations.keys())


  name = ''.join([i for i in name if i != ' ']).lower()

  result = []
  for station in list_stations:
    if name in station.lower():
      result.append(station)

  return(result)
def top_k_min_temp_stations(stations, K):
  tuple_station_temp = sorted((value['temp'],key) for (key,value) in stations.items())




  result = [list(tuple_station_temp)[i][1] for i in range(K)]

  return result
def top_k_max_temp_stations(stations, K):
  tuple_station_temp = sorted((value['temp'],key) for (key,value) in stations.items())


  if K > len(tuple_station_temp):
    K = len(tuple_station_temp)


  result = [list(tuple_station_temp)[::-1][i][1] for i in range(K)]

  return result
def peak_stations(stations):
  lat =  sorted((value['lat'],key) for (key,value) in stations.items())
  long = sorted((value['long'],key) for (key,value) in stations.items())


  min_lat = lat[0][1]
  max_lat = lat[-1][1]

  min_long = long[0][1]
  max_long = long[-1][1]

  return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):

  lat_main, long_main = stations[main_station]['lat'], stations[main_station]['long']

  lat_long_station =  sorted((value['lat'], value['long'], key) for (key,value) in stations.items())

  result = []



  for i in lat_long_station:

    distance_ = distance(lat_main, long_main, i[0], i[1])


    result.append((distance_, i[2]))

  return [i[1] for i in sorted(result)[1:1+K]]
def average_temp(stations, names):

  total_temp = 0
  count = 0

  for i in names:
    total_temp += stations[i]['temp']
    count+=1

  return total_temp/count




# # --------------------------------------------------
# 6130097621 (30) 6 (2021-03-28 17:11)

def approx_match(stations, name):
    a = {}
    b = ""
    c = ""
    d = []
    for i in stations :
        for j in i :
            if j not in " ":
                b += j
        a[b] = i
        b=""
    for i in name:
        if i not in " ":
            i = i.upper()
            c += i
    for i in a :
        if c in i:
            d += [a[i]]

    return d
def top_k_min_temp_stations(stations, K):
    a = {}
    b = []
    c = []
    for i in stations :
        b += [[stations[i]["temp"],i]]
    b.sort()
    for i in range(K):
        c += [b[i][1]]

    return c
def top_k_max_temp_stations(stations, K):
    b = []
    c = []
    for i in stations :
        b += [[(-1)*(stations[i]["temp"]),i]]
    b.sort()

    for i in range(K):
        c += [b[i][1]]

    return c
def peak_stations(stations):
    a = []
    b = []
    c = []
    for i in stations :
        a += [[stations[i]["lat"],i]]
        b += [[stations[i]["long"],i]]
    a.sort()
    b.sort()
    c += [a[0][1]]
    c += [a[-1][1]]
    c += [b[0][1]]
    c += [b[-1][1]]

    return c
def k_nearby_stations(stations, main_station, K):
    a = [stations[main_station]["lat"],stations[main_station]["long"]]
    b = []
    d = []
    e = []
    for i in stations :
        b += [stations[i]["lat"],stations[i]["long"]]
        c = distance(a[0], a[1], b[0], b[1])
        d += [[c,i]]
        b = []
    d.sort()
    for i in range(K+1):
        e += [d[i][1]]
    e.pop(0)

    return e
def average_temp(stations, names):
    a = 0
    b = 0
    for i in names :
        a += stations[i]["temp"]
        b += 1
    avg = a / b

    return avg



# --------------------------------------------------
# 6130917221 (29.25) 7 (2021-03-29 23:51)

def approx_match(stations, name):
    x = []
    y = ''
    for i in range(len(name)):
        if name[i] != ' ':
            y += name[i]
    y = y.upper()
    for i in stations:
        i = i.upper()
        if y in i:
            x.append(i)
    return x
def top_k_min_temp_stations(stations, K):
    x = []
    y = []
    t = 0
    for i in stations:
        x.append([stations[i]['temp'], i])
    x = sorted(x)
    for i in range(len(x)):
        y.append(x[i][1])
    return y[:K]
def top_k_max_temp_stations(stations, K):
    x = []
    y = []
    z = []
    z1 = []
    z2 = []
    t = 0
    for i in stations:
        x.append([stations[i]['temp'], i])
    x = sorted(x)
    for i in x:
        i[0] *= -1
        y.append([i[0],i[1]])
    a = y[-K:]
    z1 = a[::-1]
    z1 = sorted(z1)
    for i in z1:
        i[0] *= -1
        z2.append([i[0],i[1]])
    for i in range(len(z2)):
        z.append(z2[i][1])
    return z
def peak_stations(stations):
    x = []
    for i in stations:
        minnla = stations[i]['lat']
        maxxla = stations[i]['lat']
        minnlong = stations[i]['long']
        maxxlong = stations[i]['long']
    for i in stations:
        if stations[i]['lat'] <= minnla:
            minnla = stations[i]['lat']
            minnla_name = i
        if stations[i]['lat'] >= maxxla:
            maxxla = stations[i]['lat']
            maxxla_name = i
        if stations[i]['long'] <= minnlong:
            minnlong = stations[i]['long']
            minnlong_name = i
        if stations[i]['long'] >= maxxlong:
            maxxlong = stations[i]['long']
            maxxlong_name = i
    x.append(minnla_name)
    x.append(maxxla_name)
    x.append(minnlong_name)
    x.append(maxxlong_name)
    return x
def k_nearby_stations(stations, main_station, K):
    x = stations[main_station]['lat']
    y = stations[main_station]['long']
    z1 = []
    z2 = []
    for i in stations:
        if i != main_station :
            a = stations[i]
            b = distance(x, y, a['lat'], a['long'])
            z1.append((b, i))
    z1.sort()
    for i in range(len(z1)):
        z2.append(z1[i][1])
    if len(z1) > K:
        return z2[:K]
    return z2
def average_temp(stations, names):
    x = []
    s = 0
    for i in stations:
        if i in names:
            x.append(stations[i]['temp'])
    for i in range(len(x)):
        s += x[i]
    y = s/len(x)
    return y

# --------------------------------------------------
# 6130924621 (28.74) 8 (2021-03-29 18:30)

def approx_match(stations, name):
    name = name.replace(" ","").upper()
    match_name = []
    for station_name in stations.keys():
        if name in station_name:
            match_name.append(station_name)
    return match_name
def top_k_min_temp_stations(stations, K):
    station_temp = []
    for station_name, station_info in stations.items():
        station_temp.append((station_info['temp'], station_name))
    sorted_min_temp = sorted(station_temp)
    sorted_min_temp_station = []
    for station in sorted_min_temp:
        sorted_min_temp_station.append(station[1])
    if len(sorted_min_temp) > K:
        return sorted_min_temp_station[:K]
    return sorted_min_temp_station
def top_k_max_temp_stations(stations, K):
    station_temp = []
    for station_name, station_info in stations.items():
        station_temp.append((station_info['temp'], station_name))
    sorted_min_temp = sorted(station_temp, reverse=True)
    sorted_min_temp_station = []
    for station in sorted_min_temp:
        sorted_min_temp_station.append(station[1])
    if len(sorted_min_temp) > K:
        return sorted_min_temp_station[:K]
    return sorted_min_temp_station
def peak_stations(stations):
    first_station = list(stations.keys())[0] #ใช้ค่า station แรกเป็นฐานเอาไว้เปรียบเทียบ
    min_lat = stations[first_station]['lat']
    max_lat = stations[first_station]['lat']
    min_long = stations[first_station]['long']
    max_long = stations[first_station]['long']
    min_lat_station = first_station
    min_long_station = first_station
    max_lat_sation = first_station
    max_long_station = first_station
    for station_name in list(stations.keys())[1:] : #เอา station ที่เหลือมาเทียบ
        if stations[station_name]['lat'] < min_lat :
            min_lat = stations[station_name]['lat']
            min_lat_station = station_name
        if stations[station_name]['lat'] > max_lat :
            max_lat = stations[station_name]['lat']
            max_lat_station = station_name
        if stations[station_name]['long'] < min_long :
            min_long = stations[station_name]['long']
            min_long_station = station_name
        if stations[station_name]['long'] > max_long :
            max_long = stations[station_name]['long']
            max_long_station = station_name
    return [min_lat_station, max_lat_station, min_long_station, max_long_station]
def k_nearby_stations(stations, main_station, K):
    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    cal_dis = []
    for station_name in stations.keys():
        if station_name != main_station :
            check_station = stations[station_name]
            check_distance = distance(lat_main, long_main, check_station['lat'], check_station['long'])
            cal_dis.append((check_distance, station_name))
    sorted_cal_dis = sorted(cal_dis)
    sorted_cal_dis_station = []
    for station in sorted_cal_dis:
        sorted_cal_dis_station.append(station[1])
    if len(sorted_cal_dis) > K:
        return sorted_cal_dis_station[:K]
    return sorted_cal_dis_station
def average_temp(stations, names):
    selected_temp = []
    for station_name in stations:
        if station_name in names :
            selected_temp.append(stations[station_name]['temp'])
    return sum(selected_temp)/len(selected_temp)


# --------------------------------------------------
# 6230041021 (30) 9 (2021-03-29 12:23)

def approx_match(stations, name):
    all_name = []
    name_2 = ''
    for e in range(len(name)):
        if name[e] != ' ':
           name_2 += name[e].lower()
    for i in stations:
        station_2 = ''
        for e in range(len(i)):
            if i[e] != ' ':
              station_2 += i[e].lower()
        if name_2 in station_2:
           all_name.append(i)

    return(all_name)
def top_k_min_temp_stations(stations, K):
    tempipipi = []
    for i in stations:
        tempipipi.append([stations[i]['temp'],i])
    tempipipi.sort()
    whatuwant = []
    for i in range(K):
        whatuwant.append(tempipipi[i][1])

    return(whatuwant)
def top_k_max_temp_stations(stations, K):
    tempipipi = []
    for i in stations:
        tempipipi.append([(stations[i]['temp'])*(-1),i])
    tempipipi.sort()
    whatuwant = []
    for i in range(K):
        whatuwant.append(tempipipi[i][1])

    return(whatuwant)
def peak_stations(stations):
    station_wlong = []
    for i in stations:
        station_wlong.append([stations[i]['long'],i])
    station_wlong.sort()
    station_wlati = []
    for i in stations:
        station_wlati.append([stations[i]['lat'],i])
    station_wlati.sort()
    lit_r = []
    lit_r.append(station_wlati[0][1])
    lit_r.append(station_wlati[-1][1])
    lit_r.append(station_wlong[0][1])
    lit_r.append(station_wlong[-1][1])

    return(lit_r)
def k_nearby_stations(stations, main_station, K):
    long1 = stations[main_station]['long']
    lat1 = stations[main_station]['lat']
    station_near = []
    for i in stations:
        station_near.append([distance(lat1, long1, stations[i]['lat'], stations[i]['long']),i])
    station_near.sort()
    station_near_03 = []
    for i in range(1,K+1):
        station_near_03.append(station_near[i][1])

    return(station_near_03)
def average_temp(stations, names):
    avg_name = 0
    c = 0
    for i in names:
       avg_name += stations[i]['temp']
       c += 1
    avg_name = avg_name/c

    return(avg_name )




# --------------------------------------------------
# 6230092021 (30) 10 (2021-03-28 08:11)

def approx_match(stations, name):
    name = name.upper()
    name2 = ''
    for i in name:
        if i == ' ':
            name2 += ''
        else:
            name2 += i
    namestation = []
    selected = []
    for ns in stations:
        namestation.append(ns)
    for i in namestation:
        if name2 in i:
            selected.append(i)

    return selected
def top_k_min_temp_stations(stations, K):
    kstation=[]
    for i in stations:
        kstation.append([stations[i]['temp'],i])
    kstation.sort()
    mintemp=[]
    for i in range(K):
        mintemp.append(kstation[i][1])
    return mintemp
def top_k_max_temp_stations(stations, K):
    kstation=[]
    for i in stations:
        y=(stations[i]['temp'])*-1
        kstation.append([y,i])
    kstation.sort()
    maxtemp=[]
    for i in range(K):
        maxtemp.append(kstation[i][1])
    return maxtemp
def peak_stations(stations):
    peak = []
    lat1 = []
    for i in stations:
        lat1.append([stations[i]['lat'],i])
    lat1.sort()
    peak.append(lat1[0][1])
    lat2 = []
    for i in stations:
        rev = stations[i]['lat']*-1
        lat2.append([rev,i])
    lat2.sort()
    peak.append(lat2[0][1])
    long1 = []
    for i in stations:
        long1.append([stations[i]['long'],i])
    long1.sort()
    peak.append(long1[0][1])
    long2 = []
    for i in stations:
        rev2 = (stations[i]['long'])*-1
        long2.append([rev2,i])
    long2.sort()
    peak.append(long2[0][1])

    return peak
def k_nearby_stations(stations, main_station, K):
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    kstation=[]

    for i in stations:
        lat2=stations[i]['lat']
        long2=stations[i]['long']
        kstation.append([distance(lat1,long1,lat2,long2),i])
    kstation.sort()
    kstation.remove(kstation[0])
    nearby = []
    for i in range(K):
        nearby.append(kstation[i][1])

    return nearby
def average_temp(stations, names):
    sm = 0
    for i in names:
        for j in stations:
            if i == j:
                sm = sm + stations[j]['temp']
    avg = sm/len(names)

    return avg

# --------------------------------------------------
# 6230131921 (29.6) 11 (2021-03-29 19:55)

def approx_match(stations, name):
    big = name.upper()
    erasecut = ""
    for e in big:
        if "A"<=e<="z":
            erasecut+=e
    k1 = []
    k2 = []
    for e in stations:
        k1.append(e)
    for e in k1:
        if erasecut in e:
            k2.append(e)
    return k2
def top_k_min_temp_stations(stations, K):
    l1 = []
    l2 = []
    l3 = []
    for e in stations:
        l1.append(stations[e]["temp"])
        l1.append(e)
        l2.append(l1)
        l1 = []
    l2.sort()
    for i in range(K):
        if i < len(l2):
            l3.append(l2[i][1])
        else:
            break
    return l3
def top_k_max_temp_stations(stations, K):
    m1 = []
    m2 = []
    m3 = []
    for e in stations:
        m1.append(-stations[e]["temp"])
        m1.append(e)
        m2.append(m1)
        m1 = []
    m2.sort()
    for i in range(len(m2)):
        m2[i][0]*=-1
    for i in range(K):
        if i < len(m2):
            m3.append(m2[i][1])
        else:
            break
    return m3
def peak_stations(stations):
    j1 = []
    j2 = []
    j3 = []
    j4 = []
    for e in stations:
        j1.append(stations[e]["lat"])
        j1.append(e)
        j2.append(stations[e]['long'])
        j2.append(e)
        j3.append(j1)
        j4.append(j2)
        j1=[]
        j2=[]
    mij3 = min(j3)
    maj3 = max(j3)
    mij4 = min(j4)
    maj4 = max(j4)
    return mij3[1], maj3[1], mij4[1], maj4[1]
def k_nearby_stations(stations, main_station, K):
    el1 = []
    el2 = []
    el3 = []
    el4 = []
    el5 = []
    el6 = []
    el7 = []
    for e in stations:
        el1.append(e)
        el2.append(stations[e]['lat'])
        el3.append(stations[e]['long'])
    for i in range(len(el1)):
        if el1[i] == main_station:
            num1 = el1.index(main_station)
            for i in range(len(el1)):
                ans1 = distance(el2[num1],el3[num1],el2[i],el3[i])
                el4.append(ans1)
                el4.append(el1[i])
                el5.append(el4)
                el4 = []
    el5.sort()
    el6 = el5[1::]
    for i in range(K):
        if i < len(el6):
            el7.append(el6[i][1])
        else:
            break

    return el7
def average_temp(stations, names):
    m1 = []
    m2 = []
    m3 = []
    average = 0
    for e in stations:
        m1.append(e)
        m1.append(stations[e]['temp'])
        m2.append(m1)
        m1 = []
    for i in range(len(m2)):
        for e in names:
            if e == m2[i][0]:
                m3.append(m2[i][1])
    for i in range(len(m3)):
        average += m3[i]
    final = average / len(m3)
    return final
# --------------------------------------------------
# 6230133121 (21) 12 (2021-03-29 03:16)

def approx_match(stations, name):
    names = []
    name = name.upper()
    Name = ''
    for s in name:
        if 'A'<=s<='Z':
            Name+=s
    for key in stations:
        if Name in key:
            names.append(key)
    return names
def top_k_min_temp_stations(stations, K):
    temp_pro = []
    temp_K = []
    for province in stations:
        A = stations[province]
        temp_pro.append([A['temp'],province])
    temp_pro.sort()
    T = temp_pro[0:K]
    for e in T:
        temp_K.append(e[1])
    return temp_K
def top_k_max_temp_stations(stations, K):
    temp_pro = []
    temp_K = []
    for province in stations:
        A = stations[province]
        temp_pro.append([-A['temp'],province])
    temp_pro.sort()
    T = temp_pro[0:K]
    for e in T:
        temp_K.append(e[1])
    return temp_K
def peak_stations(stations):
    lat_pro = []
    long_pro = []
    for province in stations:
        A = stations[province]
        lat_pro.append([A['lat'],province])
        long_pro.append([A['long'],province])
    lat_pro.sort()
    long_pro.sort()
    T=[lat_pro[0][1],lat_pro[-1][1],long_pro[0][1],long_pro[-1][1]]
    return T
def k_nearby_stations(stations, main_station, K):
    import math
    M = stations[main_station]
    D=[]
    D1 = []
    for province in stations:
        A = stations[province]
        d= distance(A['lat'], A['long'], M['lat'], M['long'])
        D.append([d,province])
    D.sort()
    D = D[0:K]
    for e in D:
        D1.append(e[1])
    return D1
def average_temp(stations, names):
    T = {}
    for e in names:
        T[e] = stations[e]
    for province in T:
        A = T[province]
        return A['temp']

# --------------------------------------------------
# 6230153721 (30) 13 (2021-03-29 18:23)

def approx_match(stations, name):
    name=name.split()
    Name=''
    N=[]
    for i in name:
        Name+=i.lower()
    for i in stations:
        k=i.split()
        n=''
        for j in k:
            n+=j.lower()
        for t in range(len(n)):
            if n[t:t+len(Name)]==Name:
                N.append(i)
                break
    return N
def top_k_min_temp_stations(stations, K):
    l=[]
    L=[]
    for i in stations:
        l.append([stations[i]['temp'],i])
    l.sort()
    if len(l)>=K:
        for i in range(K):
            L.append(l[i][1])
    else:
        for i in l:
            L.append(i[1])
    return L
def top_k_max_temp_stations(stations, K):
    l=[]
    L=[]
    for i in stations:
        l.append([stations[i]['temp'],i])
    l.sort()
    x={}
    p={}
    for i in l:
        if str(i[0]) not in x:
            x[str(i[0])]=[i[1]]
        elif str(i[0]) in x:
            x[str(i[0])]+=[i[1]]
    for i in x:
        if len(x[i])>1:
            p[i]=x[i]
    k=0
    f=[]
    for i in range(len(l)):
        if str(l[-1-i][0]) in p and l[-1-i][0] not in f:
            k=0
            f.append(l[-1-i][0])
            l[-1-i][1]=p[str(l[-1-i][0])][k]
            k=1
        elif str(l[-1-i][0]) in p and l[-1-i][0] in f:
            l[-1-i][1]=p[str(l[-1-i][0])][k]
            k+=1
    if K<=len(l):
        for i in range(K):
            L.append(l[-1-i][1])
    else:
        for i in range(len(l)):
            L.append(l[-1-i][i])
    return L
def peak_stations(stations):
    M=[]
    lat=[]
    long=[]
    for i in stations:
        lat.append([stations[i]['lat'],i])
        long.append([stations[i]['long'],i])
    lat.sort()
    long.sort()
    M.append(lat[0][1])
    M.append(lat[-1][1])
    M.append(long[0][1])
    M.append(long[-1][1])
    return M
def k_nearby_stations(stations, main_station, K):
    l=[]
    N=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for i in stations :
        lat2=stations[i]['lat']
        long2=stations[i]['long']
        s=distance(lat1,long1,lat2,long2)
        l.append([s,i])
    l.sort()
    l=l[1:len(l)]
    if K<=len(l):
        for i in range(K):
            N.append(l[i][1])
    else:
        for i in l:
            N.append(i[1])
    return N
def average_temp(stations, names):
    t=0
    for i in names:
        t+=stations[i]['temp']
    T=t/len(names)
    return T


# --------------------------------------------------
# 6230154321 (30) 14 (2021-03-29 21:08)

def approx_match(stations, name):
    name = name.upper()
    f=''
    a=[]
    for i in name :
        if i!=' ':
            f+=i
    for n in stations:
        if f in n:
            a.append(n)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    e=[]
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort()
    i=a[:K]
    for h in i:
        e.append(h[1])

    return e
def top_k_max_temp_stations(stations, K):
    a=[]
    e=[]
    for i in stations:
        a.append([-stations[i]['temp'],i])
    a.sort()
    i=a[:K]
    for h in i:
        e.append(h[1])

    return e
def peak_stations(stations):

    a=[]
    b=[]
    for i in stations:
        a.append([stations[i]['lat'],i])
        b.append([stations[i]['long'],i])
    a.sort()
    b.sort()

    min_lat=[a[0][1]]
    max_lat=[a[-1][1]]
    min_long=[b[0][1]]
    max_long=[b[-1][1]]
    return min_lat+max_lat+min_long+max_long
def k_nearby_stations(stations, main_station, K):
    a=[]
    for i in stations:
        if i!= main_station:
            b=distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long'])
            a.append([b,i])
    a.sort()
    c=a[:K]
    d=[]
    for n in c:
        d.append(n[1])
    return d
def average_temp(stations, names):
    sum=0
    for i in names:
        sum+=stations[i]['temp']

    r=sum/len(names)
    return r



# --------------------------------------------------
# 6230444321 (30) 15 (2021-03-29 20:55)

def approx_match(stations, name):
    s = ""
    for i in name:
        if i != " ":
            s += i
    x = s.upper()
    a = []
    for i in stations:
        if x in i:
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    T = []
    for i in stations:
        T.append(float(stations[i]['temp']))
    T.sort()
    a = []
    for w in range(K+countx(T)):
        for i in stations:
            if T[w] == stations[i]['temp'] and i not in a:
                a.append(i)
                break
    return a[:K]
def top_k_max_temp_stations(stations, K):
    T = []
    for i in stations:
        T.append(float(stations[i]['temp']))
    T.sort()
    T.reverse()
    a = []
    for w in range(K+countx(T)):
        for i in stations:
            if T[w] == stations[i]['temp'] and i not in a:
                a.append(i)
                break
    return a[:K]
def peak_stations(stations):
    lat = []
    long = []
    for name in stations :
        lat.append([stations[name]['lat'],name])
        long.append([stations[name]['long'],name])
    lat.sort()
    long.sort()
    ans = [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return ans
def k_nearby_stations(stations, main_station, K):
    return [pair[1] for pair in sorted([[distance(stations[main_station]['lat'], stations[main_station]['long'], stations[key]['lat'], stations[key]['long']),key] for key in stations])][1:K+1]
def average_temp(stations, names):
    T = 0
    for i in names:
        T += float((stations[i]['temp']))
    return (T/len(names))
# --------------------------------------------------
def countx(n):
    a = []
    for i in n:
        a.append(n.count(i))
    return max(a)
# 6231004021 (29.6) 16 (2021-03-29 11:48)

def approx_match(stations, name):
    searched_station = []

    name = name.replace(' ', '').upper()

    for station in stations:
        n_station = station.replace(' ', '').upper()
        if n_station.find(name) != -1:
            searched_station.append(station)

    return searched_station
def top_k_min_temp_stations(stations, K):
    n_station = {}
    for station in stations:
        n_station[station] = stations[station]

    n_station = sorted(n_station.items(), key=lambda x: x[1]['temp'])
    n_station = [n[0] for n in n_station]
    return n_station[:K if len(n_station) > K else len(n_station)]
def top_k_max_temp_stations(stations, K):
    n_station = {}
    for station in stations:
        n_station[station] = stations[station]

    n_station = sorted(n_station.items(), key=lambda x: x[1]['temp'], reverse=True)
    n_station = [n[0] for n in n_station]
    return n_station[:K if len(n_station) > K else len(n_station)]
def peak_stations(stations):

    max_lat = max(stations.items(), key=lambda x: x[1]['lat'])
    min_lat = min(stations.items(), key=lambda x: x[1]['lat'])
    max_long = max(stations.items(), key=lambda x: x[1]['long'])
    min_long = min(stations.items(), key=lambda x: x[1]['long'])
    return min_lat[0], max_lat[0], min_long[0], max_long[0]
def k_nearby_stations(stations, main_station, K):
    n_station = {}
    for station in stations:
        if station != main_station:
            n_station[station] = stations[station]

    n_station = sorted(n_station.items(), key=lambda x: distance(x[1]['lat'], x[1]['long'], stations[main_station]['lat'], stations[main_station]['long']))

    n_station = [n[0] for n in n_station]

    return n_station[:K if len(n_station) > K else len(n_station)]
def average_temp(stations, names):
    temp_list = []
    for station in stations:
        if station in names:
            temp_list.append(stations[station]['temp'])

    return sum(temp_list)/len(temp_list)


# --------------------------------------------------
# 6231008621 (0) 17 (2021-03-29 23:39)

# 6231012021 (30) 18 (2021-03-27 11:59)

def approx_match(stations, name):
    name=name.strip().upper()
    name_no_blank=''
    for i in name:
        if i!=' ':
            name_no_blank+=i
    ans=[]
    for i in stations:
        if name_no_blank in i:
            ans.append(i)
    return ans
def top_k_min_temp_stations(stations, K):
    val_ke_lst=[]
    for i in stations:
        val_ke_lst.append([stations[i]['temp'],i])
    val_ke_lst.sort()
    c=0
    ans=[]
    while c!=K:
        ans.append(val_ke_lst[c][1])
        c+=1
    return ans
def top_k_max_temp_stations(stations, K):
    val_ke_lst=[]
    for i in stations:
        y=(stations[i]['temp'])*(-1)
        val_ke_lst.append([y,i])
    val_ke_lst.sort()
    c=0
    ans=[]
    while c!=K:
        ans.append(val_ke_lst[c][1])
        c+=1
    return ans
def peak_stations(stations):
    minn_lat=[]
    for a in stations:
        minn_lat.append([stations[a]['lat'],a])
    minn_lat.sort()

    maxx_lat=[]
    for i in stations:
        y=(stations[i]['lat'])*(-1)
        maxx_lat.append([y,i])
    maxx_lat.sort()

    minn_lon=[]
    for j in stations:
        minn_lon.append([stations[j]['long'],j])
    minn_lon.sort()

    maxx_lon=[]
    for k in stations:
        y=(stations[k]['long'])*(-1)
        maxx_lon.append([y,k])
    maxx_lon.sort()

    ans=[]
    ans.append(minn_lat[0][1])
    ans.append(maxx_lat[0][1])
    ans.append(minn_lon[0][1])
    ans.append(maxx_lon[0][1])
    return ans
def k_nearby_stations(stations, main_station, K):
    val_ke_lst=[]
    x=stations[main_station]['lat']
    y=stations[main_station]['long']
    for i in stations:
        lati=stations[i]['lat']
        longg=stations[i]['long']
        val_ke_lst.append([distance(x, y, lati, longg),i])
    val_ke_lst.sort()
    val_ke_lst.remove(val_ke_lst[0])
    c=0
    ans=[]
    while c!=K:
        ans.append(val_ke_lst[c][1])
        c+=1
    return ans
def average_temp(stations, names):
    smm=0
    for i in names:
        for e in stations:
            if i==e:
                smm+=stations[e]['temp']
    return smm/len(names)



# --------------------------------------------------
# 6231019521 (30) 19 (2021-03-26 21:48)

def approx_match(stations, name):
    x=''
    for c in name:
        if 'A'<= c.upper()<='Z':
            x+=c.upper()
    sta=[]
    for e in stations:
        if x in e:
            sta.append(e)
    return sta
def top_k_min_temp_stations(stations, K):
    x=[]
    for c in stations:
        x.append([stations[c]['temp'],c])
    x.sort()
    min_temp=[]
    for i in range(K):
        min_temp.append(x[i][1])
    return min_temp
def top_k_max_temp_stations(stations, K):
    x=[]
    for c in stations:
        x.append([(stations[c]['temp']*(-1)),c])
    x.sort()
    max_temp=[]
    for i in range(K):
        max_temp.append(x[i][1])
    return max_temp
def peak_stations(stations):
    latt=[]
    for c in stations:
        latt.append([stations[c]['lat'],c])
    latt.sort()
    longg=[]
    for e in stations:
        longg.append([stations[e]['long'],e])
    longg.sort()
    final=[]
    final.append(latt[0][1])
    final.append(latt[-1][1])
    final.append(longg[0][1])
    final.append(longg[-1][1])
    return final
def k_nearby_stations(stations, main_station, K):
    lat_main=stations[main_station]['lat']
    long_main=stations[main_station]['long']
    x=[]
    for c in stations:
        latt=stations[c]['lat']
        longg=stations[c]['long']
        dis=distance(lat_main,long_main,latt,longg)
        x.append([dis,c])
    x.sort()
    ans=[]
    for i in range(1,K+1):
        ans.append(x[i][1])
    return ans
def average_temp(stations, names):
    s=0
    for c in stations:
        if c in names:
            s+=stations[c]['temp']
    avg=s/len(names)
    return avg




# --------------------------------------------------
# 6231205921 (27.54) 20 (2021-03-29 16:18)

def approx_match(stations, name):
    name = name.upper().split()
    list_pv = []
    k = 0
    for c in stations :
        for i in name :
            if i in c :
                k += 1
        if k == len(name) :
            list_pv.append(c)
        k = 0
    return list_pv
def top_k_min_temp_stations(stations, K):
    min_temp = []
    for c in stations :
        min_temp.append([stations[c]['temp'],c])
    min_temp.sort()
    temp_pv = []
    for i in range(K) :
        temp_pv.append(min_temp[i][1])
    return temp_pv
def top_k_max_temp_stations(stations, K):
    min_temp = []
    for c in stations :
        min_temp.append([stations[c]['temp'],c])
    min_temp.sort()
    temp_pv = []
    for i in range(-1,-K-1,-1) :
        temp_pv.append(min_temp[i][1])
    return temp_pv
def peak_stations(stations):
    lat_max = list(stations.keys())[0]
    lat_min = list(stations.keys())[0]
    long_max = list(stations.keys())[0]
    long_min = list(stations.keys())[0]
    for s in stations:
        if stations[s]['lat'] > stations[lat_max]['lat']:
            lat_max = s
        if stations[s]['lat'] < stations[lat_min]['lat']:
            lat_min = s
        if stations[s]['long'] > stations[long_max]['long']:
            long_max = s
        if stations[s]['long'] < stations[long_min]['long']:
            long_min = s
    return [lat_min, lat_max,long_min,long_max]
def k_nearby_stations(stations, main_station, K):
    near = []
    for c in stations :
        diff = distance(float(stations[main_station]['lat']),float(stations[main_station]['long']),float(stations[c]['lat']),float(stations[c]['long']))
        near.append([diff,c])
    near.sort()
    near_pv = []
    for c in near :
        near_pv.append(c[1])
    near_pv = near_pv[1:K+1]
    return near_pv
def average_temp(stations, names):
    k = 0
    avg_temp = 0
    for c in names :
        if c in stations :
            avg_temp += stations[c]['temp']
            k +=1
    avg_temp = avg_temp/k
    return avg_temp


# --------------------------------------------------
# 6231207121 (30) 21 (2021-03-29 01:52)

def approx_match(stations, name):
    result = list()
    nname = UpDeSp(name)
    for key in stations :
        if nname in UpDeSp(key) :
            result.append(key)
    return result
def top_k_min_temp_stations(stations, K):
    result = list()
    for i in range(min(K,len(stations))) :
        result.append(ListStationTemp("pl", stations)[i][1])
    return result
def top_k_max_temp_stations(stations, K):
    result = list()
    for i in range(min(K,len(stations))) :
        result.append(ListStationTemp("mi", stations)[i][1])
    return result
def peak_stations(stations):
    lat = list()
    lon = list()
    for key in stations :
        lat.append([stations[key]['lat'], key])
        lon.append([stations[key]['long'], key])
    lat.sort()
    lon.sort()
    return [lat[0][1], lat[-1][1], lon[0][1], lon[-1][1]]
def k_nearby_stations(stations, main_station, K):
    result = list()
    coor = list() #listof lati,longi,name
    d = list() #listof distance,name
    latmain = stations[main_station]['lat']
    lonmain = stations[main_station]['long']
    for key in stations :
        coor.append([stations[key]['lat'], stations[key]['long'], key])
    for lat, long, key in coor :
        dis = distance(latmain, lonmain, lat, long)
        d.append([dis, key])
    d.sort()
    for i in range(1,min(K+1,len(d))) :
        result.append(d[i][1])
    return result
def average_temp(stations, names):
    sigmatemp = float()
    c = 0
    for key in names :
        if key in stations :
            sigmatemp += stations[key]['temp']
            c += 1
    avgtemp = sigmatemp/c
    return avgtemp

# --------------------------------------------------
def UpDeSp(text) : #Upper and Delete the Space
    result = str()
    for e in text :
        if "A" <= e.upper() <= "Z" :
            result += e.upper()
    return result
def ListStationTemp(sym, stations) : #Make List of temp and name
    result = list() #[[20.5,'Astation'],[19.0,'Bstation']]
    if sym == "pl" :
        for key in stations :
            result.append([stations[key]['temp'], key])
        result.sort()
        return result
    elif sym == "mi" :
        for key in stations :
            result.append([-stations[key]['temp'], key])
        result.sort()
        return result

#==========
# 6231213921 (18.32) 22 (2021-03-29 23:53)

def approx_match(stations, name):
    name_all_stations = []
    name = name.split()
    name = "".join(name)
    name = name.upper()
    for i in stations:
        if name in stations:
            name_all_stations.append(stations)
    return name_all_stations
def top_k_min_temp_stations(stations, K):
    min_t_stations=sorted(stations,key=lambda x: stations[x]['temp'])
    return min_t_stations[:K]
def top_k_max_temp_stations(stations, K):
    max_t_stations=sorted(stations,key=lambda x: stations[x]['temp'])[::-1]
    return max_t_stations[:K]
def peak_stations(stations):
    lat_stations=sorted(stations,key=lambda x: stations[x]['lat'])
    long_stations=sorted(stations,key=lambda x: stations[x]['long'])
    return [lat_stations[0],lat_stations[-1],long_stations[0],long_stations2[-1]]
def k_nearby_stations(stations, main_station, K):
    main_lat = stations[main_station]['lat' ] ; main_long = stations[main_station]['long']
    closet = []
    for e in stations:
        closet.append([distance(main_lat,main_long,stations[e]['lat' ],stations[e]['long']),e])
        closet.sort()
    nearby = [i[1] for i in closet[1:K+1]]
    return nearby
def average_temp(stations, names):
    avg = 0
    for pro in names:
        avg += stations[pro]['temp']
    avg/=len(names)
    return avg

# --------------------------------------------------
# 6231214521 (30) 23 (2021-03-27 00:18)

def approx_match(stations, name):

    s = ""
    name = name.upper()
    for e in name:
        if e != " ":
            s += e
    a = []
    for n in stations:
        if s in n:
            a.append(n)
    return a
def top_k_min_temp_stations(stations, K):
    ans = []
    temp = []
    for s in stations:
        temp.append([stations[s]["temp"],s])
    temp.sort()
    for e in temp[:K]:
        ans.append(e[1])
    return ans
def top_k_max_temp_stations(stations, K):
    ans = []
    temp = []
    for s in stations:
        temp.append([float(stations[s]["temp"])*(-1),s])
    temp.sort()
    for e in temp [:K]:
        ans.append(e[1])
    return ans
def peak_stations(stations):
    lat = []
    long = []
    for s in stations:
        lat.append([float(stations[s]["lat"]),s])
        long.append([float(stations[s]["long"]),s])
    lat.sort()
    long.sort()
    return [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat_min = stations[main_station]["lat"]
    long_min = stations[main_station]["long"]
    dis = []
    for s in stations:
        dis.append([distance(lat_min,long_min,stations[s]["lat"],stations[s]["long"]),s])
    dis.sort()
    ans = [e[1] for e in dis[1:K+1]]
    return ans
def average_temp(stations, names):
    s = 0
    for name in names:
        s += float(stations[name]["temp"])
    return s/len(names)



# --------------------------------------------------
# 6231220221 (22.74) 24 (2021-03-29 23:59)

def approx_match(stations, name):
    a = name.upper().split()
    b = ''.join(a)
    c = []
    for e in stations:
        if b in e:
            c.append(e)

    return c
def top_k_min_temp_stations(stations, K):
    a = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    b = []
    for i in range(K):
        b.append(a[i][1])

    return b
def top_k_max_temp_stations(stations, K):
    a = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    b = []
    for i in range(-1,-K-1,-1):
        b.append(a[i][1])

    return b
def peak_stations(stations):
    lat = []
    long = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
        long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    b = []
    latmin = lat[0][1]
    latmax = lat[-1][1]
    longmin = long[0][1]
    longmax = long[-1][1]
    peak = [latmin,latmax,longmin,longmax]

    return peak
def k_nearby_stations(stations, main_station, K):
    a = []
    for e in stations:
        dist = distance(float(stations[main_station]['lat'],float(stations[main_station]['long']),float(stations[e]['lat']),float(stations[e]['long'])))
        a.append([dist,e])
    a.sort()
    b = len(a)
    c = []
    if K>b:
        for i in range(b):
            c.append(a[i][1])
    else:
        for i in range(K):
            c.append(a[i][1])

    return c
def average_temp(stations, names):
    a = 0
    b = 0
    for e in names:
        if e in stations:
            a += stations[e]['temp']
            b += 1
    avg = a/b

    return avg

# --------------------------------------------------
# 6231222521 (28.74) 25 (2021-03-29 12:43)

def approx_match(stations, name):
    allStations = [e.lower() for e in stations.keys()]
    name = name.replace(" ","")
    name = name.lower()
    return [e.upper() for e in allStations if name in e]
def top_k_min_temp_stations(stations, K):
    temp = createSorted(stations,"temp")
    return [e[1] for e in temp[:K]]
def top_k_max_temp_stations(stations, K):
    temp = createSorted(stations,"temp")[::-1]
    return [e[1] for e in temp[:K]]
def peak_stations(stations):
    result = ["","","",""]
    lats = createSorted(stations,"lat")
    result[0] = lats[0][1]
    result[1] = lats[-1][1]
    longs = createSorted(stations,"long")
    result[2] = longs[0][1]
    result[3] = longs[-1][1]
    return result
def k_nearby_stations(stations, main_station, K):
    mLat,mLong = stations[main_station]["lat"] , stations[main_station]["long"]
    dists = [(distance(mLat,mLong,stations[e]["lat"],stations[e]["long"]),e) for e in stations if e != main_station]
    dists = sorted(dists)[:min(K,len(dists))]
    return [e[1] for e in dists]
def average_temp(stations, names):
    return sum([stations[name]["temp"] for name in names])/len(names)
# --------------------------------------------------
def createSorted(stations,prop) :
    temp = [(stations[e][prop],e) for e in stations]
    temp = sorted(temp)
    return temp
# 6231223121 (30) 26 (2021-03-28 22:56)

def approx_match(stations, name):
    n=name.upper()
    namesta=''
    for i in n:
        if i!=' ':
            namesta+=i
    for x in namesta:
        if not 'A'<=x<='Z' :
            namesta=''
            break
        else:
            pass
    stationall=[]
    for e in stations:
        stationall.append(e.upper())
    ans=[]
    if namesta!='':
        for k in range(len(stationall)):
            a=stationall[k].find(namesta)
            if a!=-1:
                ans.append(stationall[k])
        return ans
    else:
        return []
def top_k_min_temp_stations(stations, K):
    t_name=[]
    for i in stations:
        t_name.append([stations[i]['temp'],i])
    t_name.sort()
    s_k=[]
    if K>len(t_name):
        for x in range(len(t_name)):
            s_k.append(t_name[x][1])
    else:
        for x in range(K):
            s_k.append(t_name[x][1])
    return s_k
def top_k_max_temp_stations(stations, K):
    t_name=[]
    for i in stations:
        t_name.append([-1*stations[i]['temp'],i])
    t_name.sort()
    s_k=[]
    if K>len(t_name):
        for x in range(len(t_name)):
            s_k.append(t_name[x][1])
    else:
        for x in range(K):
            s_k.append(t_name[x][1])
    return s_k
def peak_stations(stations):
    lat_name=[]
    long_name=[]
    for i in stations:
        lat_name.append([stations[i]['lat'],i])
        long_name.append([stations[i]['long'],i])
    lat_name.sort()
    long_name.sort()
    lat=[lat_name[0][1],lat_name[-1][1]]
    long=[long_name[0][1],long_name[-1][1]]
    ans=lat+long
    return ans
def k_nearby_stations(stations, main_station, K):
    lat_main=stations[main_station]['lat']
    long_main=stations[main_station]['long']
    d=[]
    for i in stations:
        lat_s=stations[i]['lat']
        long_s=stations[i]['long']
        dt=distance(lat_main,long_main,lat_s,long_s)
        d.append([dt,i])
    d.sort()
    ans=[]
    if K>len(d):
        for e in range(len(d)-1):
            ans.append(d[e+1][1])
    else:
        for e in range(K):
            ans.append(d[e+1][1])
    return ans
def average_temp(stations, names):
    c=0
    for i in names:
        c+=stations[i]['temp']
    avg=c/len(names)
    return avg

# --------------------------------------------------
# 6231510221 (30) 27 (2021-03-29 23:37)

def approx_match(stations, name):
    name = onlybigletter(name)
    return [k for k in stations.keys() if name in onlybigletter(k)]
def top_k_min_temp_stations(stations, K):
    return [k[0] for k in sorted(stations.items(),\
        key=lambda item: item[1]["temp"])[0:K]]
def top_k_max_temp_stations(stations, K):
    return [k[0] for k in sorted(stations.items(),\
        key=lambda item: item[1]["temp"],reverse=True)[0:K]]
def peak_stations(stations):
    min_lat = sorted(stations.items(),key=lambda item: item[1]["lat"])[0][0]
    max_lat = sorted(stations.items(),key=lambda item: item[1]["lat"],reverse=True)[0][0]
    min_long = sorted(stations.items(),key=lambda item: item[1]["long"])[0][0]
    max_long = sorted(stations.items(),key=lambda item: item[1]["long"],reverse=True)[0][0]
    return [min_lat,max_lat,min_long,max_long]
def k_nearby_stations(stations, main_station, K):
    dis_stations = {}
    latitude = stations[main_station]['lat']
    longitude = stations[main_station]['long']
    for k,v in stations.items():
        dis_stations[k] = distance(v['lat'],v['long'],latitude,longitude)
    return [k[0] for k in sorted(dis_stations.items(),\
        key=lambda item: item[1])[1:K+1]]
def average_temp(stations, names):
    region_stations = [v['temp'] for k,v in stations.items() if k in names ]
    return sum(region_stations)/len(region_stations)

# --------------------------------------------------
def onlybigletter(name):
    return ''.join(x for x in name if x.isalpha()).upper()
# 6231511921 (27.54) 28 (2021-03-28 19:22)

def approx_match(stations, name):
    n1 = name.split()
    ch = True
    out = []
    for i in stations.keys():
        for j in n1:
            if j.lower() not in i.lower():
                ch = False
                break
        if ch:
            out.append(i)
        else:
            ch = True
    return out
def top_k_min_temp_stations(stations, K):
    l_new = []
    out = []
    for i in stations:
        l_new.append([stations[i]['temp'],i])
    l_sort = sorted(l_new)
    if(len(l_sort)<=K):
        for i in l_sort:
            out.append(i[1])
    else:
        for i in range(K):
            out.append(l_sort[i][1])
    return out
def top_k_max_temp_stations(stations, K):
    l_new = []
    out = []
    for i in stations:
        l_new.append([stations[i]['temp'],i])
    l_sort = sorted(l_new)
    l_sort.sort(reverse = True)
    if(len(l_sort)<=K):
        for i in l_sort:
            out.append(i[1])
    else:
        for i in range(K):
            out.append(l_sort[i][1])
    return out
def peak_stations(stations):
    lat_max = ""
    c_lat_max = -9999999999.99

    lat_min = ""
    c_lat_min = 9999999999.99

    long_max = ""
    c_long_max = -9999999999.99

    long_min = ""
    c_long_min = 9999999999.99

    for i in stations:
        if stations[i]['lat'] > c_lat_max:
            lat_max = i
            c_lat_max = stations[i]['lat']
        if stations[i]['lat'] < c_lat_min:
            lat_min = i
            c_lat_min = stations[i]['lat']
        if stations[i]['long'] > c_long_max:
            long_max = i
            c_long_max = stations[i]['long']
        if stations[i]['long'] < c_long_min:
            long_min = i
            c_long_min = stations[i]['long']

    return [lat_min,lat_max,long_min,long_max]
def k_nearby_stations(stations, main_station, K):
    out = []
    l = []
    for i in stations:
        l.append([distance(stations[main_station]['lat'], stations[main_station]['long'], stations[i]['lat'], stations[i]['long']),i])
    l_sort = sorted(l)
    if len(l) > K+1:
        for i in range(1,K+1,1):
            out.append(l_sort[i][1])
    else:
        for i in l_sort:
            if i[1] != main_station:
               out.append(i[1])
    return out
def average_temp(stations, names):
    c_temp = 0.00
    for i in names:
        c_temp += stations[i]['temp']
    avg_temp = c_temp/len(names)
    return avg_temp

# --------------------------------------------------
# 6231707621 (30) 29 (2021-03-27 15:13)

def approx_match(stations, name):
    names=[]
    tname=transform(name)
    for e in stations:
        nname=transform(e)
        if tname in nname:
            names.append(e.upper())
    return names
def top_k_min_temp_stations(stations, K):
    names=[]
    temp=[]
    for e in stations:
         temp.append([stations[e]['temp'],e])
    temp.sort()
    for i in range(K):
        names.append(temp[i][1])
    return names
def top_k_max_temp_stations(stations, K):
    names=[]
    temp=[]
    for e in stations:
         temp.append([-stations[e]['temp'],e])
    temp.sort()
    for i in range(K):
        names.append(temp[i][1])
    return names
def peak_stations(stations):
    names=[]
    lat=[]
    long=[]
    for e in stations:
         lat.append([stations[e]['lat'],e])
         long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    names.append(lat[0][1])
    names.append(lat[-1][1])
    names.append(long[0][1])
    names.append(long[-1][1])
    return names
def k_nearby_stations(stations, main_station, K):
    dis=[]
    names=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for e in stations:
        lat2=stations[e]['lat']
        long2=stations[e]['long']
        d=distance(lat1, long1, lat2, long2)
        dis.append([d,e])
    dis.sort()
    for i in range(K):
        names.append(dis[i+1][1])
    return names
def average_temp(stations, names):
    temp=0
    for e in stations:
        if e in names:
            temp+=stations[e]['temp']
    return temp/len(names)

# --------------------------------------------------
def transform(x):
    nname=''
    for e in x:
        if 'A'<=e.upper()<='Z':
            nname+=e.upper()
        elif e==' ':
            pass
        else:
            nname+=e
    return nname
# 6231709921 (30) 30 (2021-03-29 18:06)

def approx_match(stations, name):
    aws = []
    n = ''
    for e in name :
        if 'a'<= e.lower() <='z' :
            n+=e.lower()

    for e in stations :
        h = ''
        for lett in e :
            if 'a'<= lett.lower() <='z' :
                h+=lett.lower()
        if n in h :
            aws.append(e)
    return aws
def top_k_min_temp_stations(stations, K):
    mint = []
    l1 = []
    for e in stations :
        l1.append([stations[e]['temp'],e])
    l1.sort()
    l2 = l1[:K]
    for e in l2 :
        mint.append(e[1])
    return mint
def top_k_max_temp_stations(stations, K):
    maxt = []
    l1 = []
    l2 = []
    for e in stations :
        l1.append([stations[e]['temp']*-1,e])
    l1.sort()
    for e in l1 :
        l2.append([e[0]*-1,e[1]])
    l3 = l2[:K]
    for e in l3 :
        maxt.append(e[1])
    return maxt
def peak_stations(stations):
    latlong = []
    lat1 = []
    for e in stations :
        lat1.append([stations[e]['lat'],e])
    lat1.sort()
    latlong.append(lat1[0][1])
    latlong.append(lat1[-1][1])
    long1 = []
    for e in stations :
        long1.append([stations[e]['long'],e])
    long1.sort()
    latlong.append(long1[0][1])
    latlong.append(long1[-1][1])
    return latlong
def k_nearby_stations(stations, main_station, K):
    dist = []
    keep = []
    maindist = [stations[main_station]['lat'],\
                stations[main_station]['long'],main_station]
    for e in stations :
        keep.append([stations[e]['lat'],stations[e]['long'],e])
    for e in keep :
        dist.append([distance(maindist[0],maindist[1],\
                              e[0],e[1]),e[2]])
    dist.sort()
    a = dist[1:K+1]
    aws = []
    for e in a :
        aws.append(e[1])
    return aws
def average_temp(stations, names):
    temp = []
    for e in names :
        temp.append(stations[e]['temp'])
    avg = sum(temp)/len(temp)
    return avg

# --------------------------------------------------
# 6330170421 (28.74) 31 (2021-03-28 21:46)

def approx_match(stations, name):
    ans = []

    name = name.split()
    name = ''.join(name)
    name = name.upper()
    for key in stations:
        keyz = key.split()
        keyz = ''.join(keyz)
        keyz = keyz.upper()
        if name in keyz:
                ans.append(key)
    return ans
def top_k_min_temp_stations(stations, K):
    T = []
    for key in stations:
        T.append([stations[key]['temp'], key])
    T.sort()
    x = T[0:K]

    TSm = []
    for i in x:

        TSm.append(i[1])


    return(TSm)
def top_k_max_temp_stations(stations, K):
    T = []
    for key in stations:
        T.append([stations[key]['temp'], key])
    T.sort()
    y = T[-1:-K-1:-1]

    TSM = []
    for i in y:

        TSM.append(i[1])





    return(TSM)
def peak_stations(stations):
    latt = []

    for key in stations:
        latt.append(stations[key]['lat'])
    latm = min(latt)
    latM = max(latt)

    longg = []

    for key in stations:
        longg.append(stations[key]['long'])
    longm = min(longg)
    longM = max(longg)


    for key in stations:
        a = stations[key]['lat']
        if a == latm :
            LAm = key
        if a == latM :
            LAM = key
        b = stations[key]['long']
        if b == longm :
            LOm = key
        if b == longM :
            LOM = key
    x = [LAm,LAM,LOm,LOM]


    return x
def k_nearby_stations(stations, main_station, K):
    d = []
    z = []

    x = main_station.upper()
    lat1 = stations[x]["lat"]
    long1 = stations[x]["long"]
    for key in stations:
        lat2 = stations[key]["lat"]
        long2 = stations[key]["long"]
        d.append(distance(lat1, long1, lat2, long2))
    d.sort()
    dmin = d[1:K+1]
    for i in dmin:
        for key in stations:
            lat2 = stations[key]["lat"]
            long2 = stations[key]["long"]

            if i == distance(lat1, long1, lat2, long2) :
                    z.append(key)
                    break


    return(z)
def average_temp(stations, names):
    x = 0
    for e in names :
        e = e.upper()
        x += stations[e]['temp']
    z = x/len(names)
    return z



# --------------------------------------------------
# 6330171021 (24.72) 32 (2021-03-27 00:42)

def approx_match(stations, name):
    x = []
    y = ''
    name = name.upper()
    for i in name:
        y += i
    for i in stations.keys():
        if y in i:
            x += [i]
    return x
def top_k_min_temp_stations(stations, K):
    x = []
    y = []
    for i in stations:
        x.append([stations[i]['temp'],i])
    x.sort()
    for e in range(K):
        if e < len(x):
            y.append(x[e][1])
        else:
            break
    return y
def top_k_max_temp_stations(stations, K):
    x = []
    y = []
    for i in stations:
        x.append([stations[i]['temp'],i])
    x.sort()
    x = x[-1::-1]
    for e in range(K):
        if e < len(x):
            y.append(x[e][1])
        else:
            break
    return y
def peak_stations(stations):
    x = {}
    y = {}
    a = []
    b = []
    c = []
    for i in stations:
        p = stations[i]['lat']
        x[p] = i
    for e in x:
        a.append(e)
    a.sort()
    b.append(x[a[0]])
    b.append(x[a[-1]])
    for f in stations:
        u = stations[f]['long']
        y[u] = f
    for g in y:
        c.append(g)
    c.sort()
    b.append(y[c[0]])
    b.append(y[c[-1]])
    return b
def k_nearby_stations(stations, main_station, K):
    x = stations[main_station]['lat']
    y = stations[main_station]['long']
    z = {}
    a = []
    b = []
    distances = 0
    for i in stations:
        if i != main_station:
            lat2 = stations[i]['lat']
            long2= stations[i]['long']
            distances = distance(x,y,lat2,long2)
            z[distances] = i
    for e in z:
        a.append([e,z[e]])
    a.sort()
    for f in range(K):
        if K < len(a):
            b.append(a[f][1])
    return b
def average_temp(stations, names):
    a = []
    b = 0
    for i in names:
        a.append(stations[i]['temp'])
    for e in a:
        b += e
    c = b/len(a)
    return c
# --------------------------------------------------
# 6330172721 (30) 33 (2021-03-28 20:29)

def approx_match(stations, name):
    name = ''.join(name.upper().split())
    lst = []
    for sttn in stations :
        sttn_u = ''.join(sttn.split())
        if name in sttn_u :
            lst.append(sttn)
    return lst
def top_k_min_temp_stations(stations, K):
    srt_sttn = sorted(stations.items() , key= lambda x:(x[1]['temp'],x[0]))
    lst = []
    for sttn in srt_sttn[:K] :
        lst.append(sttn[0])
    return lst
def top_k_max_temp_stations(stations, K):
    srt_sttn = sorted(stations.items() , key= lambda x:(-x[1]['temp'],x[0]))
    lst = []
    for sttn in srt_sttn[:K] :
        lst.append(sttn[0])
    return lst
def peak_stations(stations):
    srt_la_max = sorted(stations.items() , key= lambda x:-x[1]['lat'])
    srt_la_min = sorted(stations.items() , key= lambda x:x[1]['lat'])
    srt_lng_max = sorted(stations.items() , key= lambda x:-x[1]['long'])
    srt_lng_min = sorted(stations.items() , key= lambda x:x[1]['long'])

    la_max = srt_la_max[0][0]
    la_min = srt_la_min[0][0]
    lng_max = srt_lng_max[0][0]
    lng_min = srt_lng_min[0][0]

    lst = [la_min,la_max,lng_min,lng_max]
    return lst
def k_nearby_stations(stations, main_station, K):
    n_sttn = stations
    la_main = stations[main_station]['lat']
    lng_main = stations[main_station]['long']
    lst = []
    for i_sttn in n_sttn :
        n_sttn[i_sttn]['distance'] = distance(la_main,lng_main,n_sttn[i_sttn]['lat'],n_sttn[i_sttn]['long'])
    srt_sttn_distance = sorted(n_sttn.items() , key=lambda x:(x[1]['distance'],x[0]))
    for j_sttn in srt_sttn_distance[1:K+1] :
        lst.append(j_sttn[0])
    return lst
def average_temp(stations, names):
    ttl_temp = 0
    for ele in names :
        ttl_temp += stations[ele]['temp']
    return ttl_temp/len(names)



# --------------------------------------------------
# 6330173321 (30) 34 (2021-03-29 20:54)

def approx_match(stations, name):
    name = name.upper()
    match = []
    x = ""
    for i in name:
        if i == ' ' :
            x += ''
        else : x += i
    for i in stations:
        if x in i.upper().replace(' ',''):
            match.append(i)
    return match
def top_k_min_temp_stations(stations, K):
    K = min(len(stations), K)
    x = []
    result = []
    for i in stations:
        x.append([stations[i]['temp'],i])
    x.sort()
    target = x[0:K]
    for i in range(len(target)):
        result.append(target[i][1])
    return result
def top_k_max_temp_stations(stations, K):
    K = min(len(stations), K)
    x = []
    p = []
    result = []
    for i in stations:
        x.append([-(stations[i]['temp']),i])
    x.sort()
    for [x,y] in x:
        p.append([-x,y])
    target = p[0:K]
    for i in range(len(target)):
        result.append(target[i][1])
    return result
def peak_stations(stations):
    lat = []
    long = []
    for i in stations:
        lat.append([stations[i]['lat'],i])
        long.append([stations[i]['long'],i])
    r1 = min(lat)
    r2 = max(lat)
    r3 = min(long)
    r4 = max(long)
    return [r1[1],r2[1],r3[1],r4[1]]
def k_nearby_stations(stations, main_station, K):
    K = min(len(stations), K)
    lat_m = stations[main_station]['lat']
    long_m = stations[main_station]['long']
    x = []
    result = []
    for i in stations:
        lat_i = stations[i]['lat']
        long_i = stations[i]['long']
        d = distance(lat_m, long_m, lat_i, long_i)
        x.append([d, i])
    x.sort()
    target = x[1:K+1]
    for i in range(len(target)):
        result.append(target[i][1])
    return result
def average_temp(stations, names):
    x = 0
    for i in names:
        x += stations[i]['temp']
    result = x/len(names)
    return result
# --------------------------------------------------
# 6330174021 (23.6) 35 (2021-03-25 19:12)

def approx_match(stations, name):
    name = name.upper()
    name1 = ""
    for c in name:
        if "A" <= c.upper() <= "Z":
            name1 += c
    return [station for station in stations if name1 in station]
def top_k_min_temp_stations(stations, K):
     return [ sta for temp, sta in
              sorted([ [stations[station]["temp"], station] for station in stations])[:K] ]
def top_k_max_temp_stations(stations, K):
    stations = [[stations[station]["temp"], station] for station in stations]
    top_k = []
    while stations != [] and len(top_k) < K:
        x = stations[0]
        for temp, sta in stations:
            if temp > x[0]:
                x = [temp, sta]
            elif temp == x[0]:
                x = [temp, min(sta, x[1])]
        top_k.append(x[1])
        stations.remove(x)
    return top_k
def peak_stations(stations):
    k = list(stations.keys())
    fst_station = k[0]
    min_la, max_la, min_lon, max_lon = [fst_station ,stations[fst_station]["lat"]], [fst_station, stations[fst_station]["lat"]], \
                                       [fst_station, stations[fst_station]["long"]], [fst_station, stations[fst_station]["long"]]
    for station in k:
        lat = stations[station]["lat"]
        lon = stations[station]["long"]
        if lat < min_la[1]: min_la = [station, lat]
        if lat > max_la[1]: max_la = [station, lat]
        if lon < min_lon[1]: min_lon = [station, lon]
        if lon > max_lon[1]: max_lon = [station, lon]
    return min_la[0], max_la[0], min_lon[0], max_lon[0]
def k_nearby_stations(stations, main_station, K):
    return [ sta for dis, sta in
             sorted( [[distance(stations[station]["lat"], stations[station]["long"],
                                stations[main_station]["lat"], stations[main_station]["long"]) ,
                       station] for station in stations if station != "MAE HONG SON"] )[:K] ]
def average_temp(stations, names):
    tot = 0
    num = 0
    for station in stations:
        if station not in names: continue
        num = num + 1
        tot = tot + stations[station]["temp"]
    return tot / num

# --------------------------------------------------
# 6330176221 (30) 36 (2021-03-28 22:01)

def approx_match(stations, name):
    name = name.upper()
    Name = ''
    for i in range(len(name)) :
            if name[i] == ' ' :
                pass
            else :
                Name += name[i]
    P = []
    p = ''
    for k in stations :
        for i in range(len(k)) :
            if k[i] == ' ' :
                pass
            else :
                p += k[i]
        if Name in p :
            P.append(k)
        p = ''
    return P
def top_k_min_temp_stations(stations, K):
    k = []
    kk = []
    pk = []
    for i in stations :
        k.append([stations[i]['temp'], i])
    k.sort()
    if K > len(k) :
        K = len(k)
    for i in range(K) :
        if k[i][0] in kk :
            K += 1
        else :
            kk.append(k[i][0])
    for i in kk :
        a = []
        for e in stations:
            if stations[e]['temp'] == i :
                a += [e]
        for i in a :
            if i in pk :
                pass
            if len(pk) < K :
                pk.append(i)
    return pk
def top_k_max_temp_stations(stations, K):
    k = []
    kk = []
    pk = []
    for i in stations :
        k.append([-stations[i]['temp'], i])
    k.sort()
    if K > len(k) :
        K = len(k)
    for i in range(K) :
        if k[i][0] in kk :
            K += 1
        else :
            kk.append(k[i][0])
    for i in kk :
        a = []
        for e in stations:
            if stations[e]['temp'] == -i :
                a += [e]
        for i in a :
            if i in pk :
                pass
            if len(pk) < K :
                pk.append(i)
    return pk
def peak_stations(stations):
    latt = []
    la = []
    for i in stations :
        latt.append([stations[i]['lat'], i])
    latt.sort()
    la.append(latt[0][1])
    la.append(latt[-1][1])

    longg = []
    lo = []
    for i in stations :
        longg.append([stations[i]['long'], i])
    longg.sort()
    lo.append(longg[0][1])
    lo.append(longg[-1][1])

    return la + lo
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    latmain = stations[main_station]['lat']
    longmain = stations[main_station]['long']
    al = []
    for i in stations :
        if i == main_station :
            pass
        else :
            latsta = stations[i]['lat']
            longsta = stations[i]['long']
            cal = distance(latmain, longmain, latsta, longsta)
            al.append([cal, i])
    al.sort()
    if K > len(al) :
        K = len(al)
    al = al[:K]
    near = []
    for n in al :
        near.append(n[1])
    return near
def average_temp(stations, names):
    summ = 0
    for i in names :
        i = i.upper()
        summ += stations[i]['temp']
    avg = summ/len(names)
    return avg

# --------------------------------------------------
# 6330177921 (30) 37 (2021-03-26 22:34)

def approx_match(stations, name):
    show = []
    name_p = ''
    for e in name.upper():
        if e in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            name_p += e
    for n in stations:
        s = n.upper().find(name_p)
        if s != -1:
            show.append(n)
    return show
def top_k_min_temp_stations(stations, K):
    temp_name = []
    show = []
    for e in stations:
        temp_name.append([stations[e]['temp'],e])
    temp_name.sort()
    for i in range(K):
        show.append(temp_name[i][1])
    return show
def top_k_max_temp_stations(stations, K):
    temp_name = []
    show = []
    for e in stations:
        temp_name.append([-stations[e]['temp'],e])
    temp_name.sort()
    for i in range(K):
        show.append(temp_name[i][1])
    return show
def peak_stations(stations):
    lat_name = []
    long_name = []
    peak = []
    for e in stations:
        lat_name.append([stations[e]['lat'],e])
        long_name.append([stations[e]['long'],e])
    lat_name.sort()
    long_name.sort()
    peak.append(lat_name[0][1])
    peak.append(lat_name[-1][1])
    peak.append(long_name[0][1])
    peak.append(long_name[-1][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    dis_name = []
    name = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for e in stations:
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        dis = distance(lat1,long1,lat2,long2)
        dis_name.append([dis,e])
    dis_name.sort()
    for i in range(1,K+1):
        name.append(dis_name[i][1])
    return name
def average_temp(stations, names):
    temp = []
    av = 0
    for e in names:
        temp.append(stations[e]['temp'])
    for e in temp:
        av += e
    return av/(len(temp))

# --------------------------------------------------
# 6330178521 (30) 38 (2021-03-28 19:41)

def approx_match(stations, name):
    newname = ''
    newstations = ''
    serch = []
    newlist = []
    for i in range(len(name)):
        if name[i] == ' ':
            pass
        else:
            newname += name[i]
    newname = newname.upper()

    for j in stations:
        for i in range(len(j)):
            if j[i] == ' ':
                pass
            else:
                newstations += j[i]
        if newname in newstations:
            serch.append(j)
        newstations = ''

    return serch
def top_k_min_temp_stations(stations, K):
    r = []
    c = []
    for i in stations:
        c.append([float(stations[i]['temp']), i])
    c.sort()
    for i in range (K):
        r.append(c[i][1])

    return r
def top_k_max_temp_stations(stations, K):
    r = []
    c = []
    for i in stations:
        c.append([-float(stations[i]['temp']), i])
    c.sort()
    for i in range (K):
        r.append(c[i][1])

    return r
def peak_stations(stations):
    r = []
    c = []
    d = []
    for i in stations:
        c.append([float(stations[i]['lat']), i])
    c.sort()
    r.append(c[0][1])
    r.append(c[-1][1])

    for i in stations:
        d.append([float(stations[i]['long']), i])
    d.sort()
    r.append(d[0][1])
    r.append(d[-1][1])

    return r
def k_nearby_stations(stations, main_station, K):
    r = []
    d = []
    c = []
    main_station = main_station.upper()
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for i in stations:
        d.append([distance(lat1, long1,float(stations[i]['lat']),float(stations[i]['long'])), i])
    d.sort()
    for i in range(K):
        c.append(d[i+1][1])

    return c
def average_temp(stations, names):
    sumary = 0
    for i in names :
        sumary += stations[i]['temp']
    avg = sumary/len(names)
    return avg

# --------------------------------------------------
# 6330179121 (30) 39 (2021-03-27 23:59)

def approx_match(stations, name):
    name = ''.join(name.upper().split())
    keepStation = []
    for i in stations :
        if name in ''.join(i.upper().split()) :
            keepStation.append(i)
    return keepStation
def top_k_min_temp_stations(stations, K):
    keepStation = {}
    output = []
    for i in stations.items() :
        keepStation[i[0]] = i[1]['temp']
    sortedKeep = sorted(keepStation.items(), key=lambda x: x[1])
    sortedAgain = []
    nMin = sortedKeep[0][1]
    subKeep = []
    for i in sortedKeep :
        if i[1] == nMin :
            subKeep.append(i)
        else :
            subKeep.sort()
            sortedAgain += subKeep
            subKeep.clear()
            subKeep.append(i)
            nMin = i[1]
    sortedAgain.append(subKeep[-1])
    keepKStation = sortedAgain[:K]
    for i in keepKStation :
        join = i[0]
        output.append(join)
    return output
def top_k_max_temp_stations(stations, K):
    keepStation = {}
    output = []
    for i in stations.items() :
        keepStation[i[0]] = i[1]['temp']
    sortedKeep = sorted(keepStation.items(), key=lambda x: x[1], reverse = True)
    sortedAgain = []
    nMin = sortedKeep[0][1]
    subKeep = []
    for i in sortedKeep :
        if i[1] == nMin :
            subKeep.append(i)
        else :
            subKeep.sort()
            sortedAgain += subKeep
            subKeep.clear()
            subKeep.append(i)
            nMin = i[1]
    sortedAgain.append(subKeep[-1])
    keepKStation = sortedAgain[:K]
    for i in keepKStation :
         join = i[0]
         output.append(join)
    return output
def peak_stations(stations):
    keepLat = {}
    for i in stations.items() :
        keepLat[i[0]] = i[1]['lat']
    keepLatSorted = sorted(keepLat.items(), key=lambda x: x[1])
    latMax = keepLatSorted[-1][0]
    latMin = keepLatSorted[0][0]
    keepLong = {}
    for i in stations.items() :
        keepLong[i[0]] = i[1]['long']
    keepLongSorted = sorted(keepLong.items(), key=lambda x: x[1])
    longMax = keepLongSorted[-1][0]
    longMin = keepLongSorted[0][0]
    out = [latMin,latMax,longMin,longMax]
    return out
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    keepDis = {}
    dataMain = stations[main_station]
    for i in stations.items() :
        distances = distance(i[1]['lat'], i[1]['long'], dataMain['lat'], dataMain['long'])
        keepDis[i[0]] = distances
    keepDisSort = sorted(keepDis.items(), key=lambda x: x[1])
    keepDisK = keepDisSort[1:K+1]
    out = []
    for i in keepDisK :
        subOut = i[0]
        out.append(subOut)
    return out
def average_temp(stations, names):
    keepTemp = []
    for i in names :
        keepTemp.append(stations[i]['temp'])
    avg = round(sum(keepTemp) / len(keepTemp), 1)
    return avg

# --------------------------------------------------
# 6330180721 (29.6) 40 (2021-03-28 22:34)

def approx_match(stations, name):
    name = name.upper()
    na=''; ans = []; pro = ''
    for e in name:
        if e!=' ':na+=e
    for e in stations:
        for i in e:
            if not i==' ':pro+=i
        if na in pro.upper():
            ans.append(e)
        pro = ''
    return ans
def top_k_min_temp_stations(stations, K):
    ans = []; b = []
    for e in stations:
        ans.append([stations[e]['temp'],e])
    ans.sort()
    for e in ans:
        b.append(e[1])
    if K>len(ans):return b
    else:
        return b[:K]
def top_k_max_temp_stations(stations, K):
    ans = []; b = []
    for e in stations:
        ans.append([-stations[e]['temp'],e])
    ans.sort()
    for e in ans:
        b.append(e[1])
    if K>len(ans):return b
    else:
        return b[:K]
def peak_stations(stations):
    lat = []; long = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
        long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    return lat[0][1],lat[-1][1],long[0][1],long[-1][1]
def k_nearby_stations(stations, main_station, K):
    near = []; ans=[]
    for e in stations:
        near.append([distance(stations[main_station]['lat'],stations[main_station]['long']\
                 ,stations[e]['lat'],stations[e]['long']),e])
    near.sort()
    near = near[1:]
    for e in near:
        ans.append(e[1])
    if K>len(near):return ans
    else:return ans[:K]
def average_temp(stations, names):
    average = 0
    for e in names:
        average += stations[e]['temp']
    return average/len(names)

# --------------------------------------------------
# 6330181321 (30) 41 (2021-03-27 15:08)

def approx_match(stations, name):
    new_stations=[]
    sta=[]
    n=name.upper().strip()
    na=''
    staa=[]
    for i in n:
        if i!=' ':
            na+=i
        else:
            na+=''
    for i in stations:
        s=''
        for e in i:
            if e!=' ':
                s+=e
            else:
                s+=''
        if na in s:
            staa.append(i)


    return(staa)
def top_k_min_temp_stations(stations, K):
    a=[]
    minn=[]
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort()

    for i in range(K):
        minn.append(a[i][1])
    return(minn)
def top_k_max_temp_stations(stations, K):
    a=[]
    maxx=[]
    for i in stations:
        a.append([-float(stations[i]['temp']),i])
    a.sort()

    for i in range(K):
        maxx.append(a[i][1])
    return(maxx)
def peak_stations(stations):
    a=[]
    b=[]

    for i in stations:
        a.append([stations[i]['lat'],i])
        b.append([stations[i]['long'],i])
    a.sort()
    b.sort()
    minlat=a[0][1]
    maxlat=a[-1][1]
    minlong=b[0][1]
    maxlong=b[-1][1]

    return([minlat,maxlat,minlong,maxlong])
def k_nearby_stations(stations, main_station, K):
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    a=[]
    near=[]
    for i in stations:
        a.append([distance(lat1, long1, stations[i]['lat'], stations[i]['long']),i])
    a.sort()
    for i in range(K+1):
        near.append(a[i][1])
    near=near[1:]
    return(near)
def average_temp(stations, names):
    a=0
    n=0
    for i in names:
        a+=(stations[i]['temp'])
        n+=1
    return(a/n)



# --------------------------------------------------
# 6330182021 (29.25) 42 (2021-03-28 23:20)

def approx_match(stations, name):
    a=''
    apm=[]
    for e in name:
        e=e.upper()
        if e not in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            a+=''
        else:
            a+=e
    for k in stations:
        if a in k:
            apm.append(k)
    return apm
def top_k_min_temp_stations(stations, K):
    tan=[]
    for e in stations:
        tan.append([stations[e]['temp'],e])
    tan.sort()
    if len(tan) >= K:
        res=tan[:K]
    elif len(tan) < K:
        res=tan
    mint=[]
    for e in res:
        mint.append(e[1])
    return mint
def top_k_max_temp_stations(stations, K):
    t_n=[]
    for e in stations:
        t_n.append([stations[e]['temp'],e])
    t_n.sort()
    if len(t_n) >= K:
        re=t_n[-K::]
    elif len(t_n) < K:
        re=t_n
    l1=re[::-1]
    nre=[]
    for i in range(len(l1)):
        l2=[]
        for j in range(len(l1)):
            if l1[i][0]==l1[j][0]:
                if l1[j] not in l2:
                    l2.append(l1[j])
            if l1[i][0]!= l1[j][0]:
                l2.sort()
        if l2 not in nre:
            nre+=l2
    mat=[]
    for e in nre:
        if e not in mat:
            mat.append(e)
    maxn=[]
    for e in mat:
        maxn.append(e[1])
    return maxn
def peak_stations(stations):
    la=[]
    lo=[]
    for k in stations:
        la.append([stations[k]['lat'],k])
        lo.append([stations[k]['long'],k])
    la.sort()
    lo.sort()
    maxla=la[-1][1]
    minla=la[0][1]
    maxlo=lo[-1][1]
    minlo=lo[0][1]
    ret=[]
    ret.append(minla)
    ret.append(maxla)
    ret.append(minlo)
    ret.append(maxlo)
    return ret
def k_nearby_stations(stations, main_station, K):
    mla=stations[main_station]['lat']
    mlo=stations[main_station]['long']
    dis=[]
    for k in stations:
        latk=stations[k]['lat']
        longk=stations[k]['long']
        dis.append([distance(mla, mlo, latk, longk),k])
    dis.sort()
    near=dis[1:K+1]
    nb=[]
    for e in near:
        nb.append(e[1])
    return nb
def average_temp(stations, names):
    temp=[]
    for e in names:
        temp.append(stations[e]['temp'])
    c=0
    n=len(temp)
    for e in temp:
        c+=float(e)
    avg =float(c/n)
    return avg

# --------------------------------------------------
# 6330183621 (30) 43 (2021-03-29 00:52)

def approx_match(stations, name):

    name=name.upper()
    new_name=''
    result=[]
    for e in name:
        if e in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            new_name += e
    for a in stations.keys():
        if new_name in a:
            result.append(a)

    return result
def top_k_min_temp_stations(stations, K):

    list_of_temp=[]
    for e in stations:
        list_of_temp.append([stations[e]['temp'],e])
    list_of_temp.sort()
    result=[]
    for i in list_of_temp:
        result.append(i[1])
    if K<len(result):
        return result[:K:]
    else:
        return result
def top_k_max_temp_stations(stations, K):

    list_of_temp=[]
    for e in stations:
        list_of_temp.append([-stations[e]['temp'],e])
    list_of_temp.sort()
    result=[]
    for i in list_of_temp:
        result.append(i[1])
    if K<len(result):
        return result[:K:]
    else:
        return result
def peak_stations(stations):

    lat=[]
    long=[]
    for e in stations:
        lat.append([stations[e]['lat'],e])
        long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    result=[lat[0][1],lat[len(lat)-1][1],long[0][1],long[len(long)-1][1]]

    return result
def k_nearby_stations(stations, main_station, K):

    main_lat=(stations[main_station]['lat'])
    main_long=(stations[main_station]['long'])
    dist=[]
    for e in stations:
        if e==main_station:
            pass
        else:
            lat1=(stations[e]['lat'])
            long1=(stations[e]['long'])
            y=distance(lat1,long1,main_lat,main_long)
            dist.append([y,e])
    dist.sort()
    result=[]
    for i in dist:
        result.append(i[1])
    if K<len(result):
        return result[:K:]
    else:
        return result
def average_temp(stations, names):

    temp_total=0
    for e in stations:
        if e in names:
            temp_total+=stations[e]['temp']
    av_temp=temp_total/len(names)

    return av_temp

# --------------------------------------------------
# 6330184221 (30) 44 (2021-03-28 22:08)

def approx_match(stations, name):

    s = []
    n = ''
    p = ''
    for e in name.upper() :
        if e != ' ' :
            n += e
    for key in stations :
        for e in key :
            if e != ' ' :
                p += e.upper()

        if n in p :
            s.append(key)
        p = ''

    return s
def top_k_min_temp_stations(stations, K):

    p = []
    sol = []
    for key in stations :
        a = stations[key]['temp']
        p.append([a,key])
    p.sort()
    p = p[:K]
    for i in range(len(p)) :
        sol.append(p[i][1])

    return sol
def top_k_max_temp_stations(stations, K):

    p = []
    sol = []
    for key in stations :
        a = stations[key]['temp']
        p.append([-a,key])
    p.sort()
    p = p[:K]
    for i in range(len(p)) :
        sol.append(p[i][1])

    return sol
def peak_stations(stations):

    sol = []
    lat_min = []
    lat_max = []
    long_min = []
    long_max = []
    for e in stations :
        lat_min.append([stations[e]['lat'],e])
        lat_max.append([stations[e]['lat'],e])
        long_min.append([stations[e]['long'],e])
        long_max.append([stations[e]['long'],e])
    lat_min.sort()
    lat_max.sort()
    long_min.sort()
    long_max.sort()
    a = lat_min[0][1]
    b = lat_max[-1][1]
    c = long_min[0][1]
    d = long_max[-1][1]

    return [a,b,c,d]
def k_nearby_stations(stations, main_station, K):

    near = []
    sol = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for e in stations :
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        dis = distance(lat1, long1, lat2, long2)
        near.append([dis,e])
        if e == main_station :
            near.remove([dis,e])
    near.sort()
    near = near[:K]
    for i in range(len(near)) :
        sol.append(near[i][1])

    return sol
def average_temp(stations, names):

    temp = []
    for e in names :
        a = stations[e]['temp']
        temp.append(a)

    return sum(temp)/len(temp)




# --------------------------------------------------
# 6330185921 (30) 45 (2021-03-27 23:24)

def approx_match(stations, name):
    name=name.upper()
    name=name.replace(' ','')
    a=[]
    for e in stations:
        if name in str(e).replace(' ',''):
            a.append(e)
    a.sort
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    for e in stations:
        if 'temp' in stations[e]:
            a.append([(stations[e]['temp']),e])
    a.sort()
    a=a[:K:]
    for i in range (len(a)):
        a[i]=a[i][1]
    return a
def top_k_max_temp_stations(stations, K):
    a=[]
    for e in stations:
        a.append([((-1*(stations[e]['temp']))),e])
    a.sort()

    a=a[0:K:]
    for i in range (len(a)):
        a[i]=a[i][1]

    return a
def peak_stations(stations):
    a=[]
    for e in stations:
        if 'lat' in stations[e]:
            a.append([stations[e]['lat'],e])
    a.sort()
    b=[]
    b.append(a[0][1])
    b.append(a[-1][1])

    c=[]
    for e in stations:
        if 'long' in stations[e]:
            c.append([stations[e]['long'],e])
    c.sort()
    b.append(c[0][1])
    b.append(c[-1][1])

    return b
def k_nearby_stations(stations, main_station, K):
    a=[]
    lat2=stations[main_station]['lat']
    long2=stations[main_station]['long']
    for e in stations:
        lat=stations[e]['lat']
        long=stations[e]['long']
        if e!=main_station :
            a.append([distance(lat,long,lat2,long2),e])
    a.sort()
    if K <= len(a):
        a=a[:K:]
    aa=[]
    for i in range(len(a)):
        aa.append((a[i])[1])
    return aa
def average_temp(stations, names):
    a=0
    for e in names:
        a=a+float(stations[e]['temp'])
    a=a/len(names)
    return a




# --------------------------------------------------
# 6330186521 (30) 46 (2021-03-29 23:48)

def approx_match(stations, name):
    upname = ''
    for c in name:
        if c != ' ':
            upname+=c.upper()
    sta = []
    for k in stations:
        upk = ''
        for c in k:
            if c != ' ':
                upk += c.upper()
        if upname in upk:
            sta.append(k)
    return sta
def top_k_min_temp_stations(stations, K):
    mink=[]
    x=[]
    for k in stations:
        x.append(stations[k]['temp'])
    x.sort()
    x=x[:K+7]
    for i in range(len(x)):
        for k in stations:
            if x[i] == stations[k]['temp']:
                if k not in mink:
                    mink.append(k)
    a=[]
    b=[]
    for i in range(len(x)):
        a.append([x[i],mink[i]])
    a.sort()
    for i in range(len(a)):
        b.append(a[i][1])

    return b[:K]
def top_k_max_temp_stations(stations, K):
    maxk=[]
    x=[]
    for k in stations:
        x.append(stations[k]['temp'])
    x.sort()
    x=x[:-K-7:-1]
    for i in range(len(x)):
        for k in stations:
            if x[i] == stations[k]['temp']:
                if k not in maxk:
                    maxk.append(k)

    a=[]
    b=[]
    for i in range(len(x)):
        a.append([-x[i],maxk[i]])
    a.sort()
    for i in range(len(a)):
        b.append(a[i][1])

    return b[:K]
def peak_stations(stations):
    peak = []
    lat = []
    long=[]
    for k in stations:
        lat.append(stations[k]['lat'])
        long.append(stations[k]['long'])
    lat.sort()
    long.sort()
    while len(peak) < 4:
        for k in stations:
            if len(peak) == 0:
                if stations[k]['lat'] == lat[0]:
                    peak.append(k)
                    break
            if len(peak) == 1:
                if stations[k]['lat'] == lat[-1]:
                    peak.append(k)
                    break
            if len(peak) == 2:
                if stations[k]['long'] == long[0]:
                    peak.append(k)
                    break
            if len(peak) == 3:
                if stations[k]['long'] == long[-1]:
                    peak.append(k)
                    break
    return peak
def k_nearby_stations(stations, main_station, K):
    near=[]
    d=[]
    for k in stations:
        d.append(distance(stations[k]['lat'],stations[k]['long'],\
        stations[main_station]['lat'],stations[main_station]['long']))
    d.sort()
    d=d[:K+1]

    for r in d:
        for k in stations:
            if r == distance(stations[k]['lat'],stations[k]['long'],\
            stations[main_station]['lat'],stations[main_station]['long']):
                near.append(k)
    a=[]
    b=[]
    for i in range(len(d)):
        a.append([d[i],near[i]])
    a.sort()
    for i in range(len(a)):
        b.append(a[i][1])
    return b[1:K+1]
def average_temp(stations, names):
    tot = 0
    for e in names:
        tot += stations[e]['temp']
    avg = tot / len(names)
    return avg




# --------------------------------------------------
# 6330187121 (30) 47 (2021-03-29 21:31)

def approx_match(stations, name):
    search = ''
    stationup = ''
    result = []
    for e in name:
        if e.upper() in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            search += e.upper()
    for f in stations:
        formatsta = ''
        for r in f:
            if r != ' ':
                formatsta += r.upper()
            if search in formatsta:
                result.append(f)
    return result
#-------------------------------------------------------------------
def top_k_min_temp_stations(stations, K):
    templist = []
    result = []
    for e in stations:
        t = stations[e]['temp']
        templist.append([t,e])
    templist.sort()
    if K > len(stations):
        K = len(stations)
    for i in range(K):
        result.append(templist[i][1])
    return result
#-------------------------------------------------------------------
def top_k_max_temp_stations(stations, K):
    templist = []
    result = []
    for e in stations:
        t = stations[e]['temp']
        templist.append([-t,e])
    templist.sort()
    if K > len(stations):
        K = len(stations)
    for i in range(K):
        result.append(templist[i][1])
    return result
#-------------------------------------------------------------------
def peak_stations(stations):
    lat = []
    lon = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
    lat.sort()
    minlat = lat[0][1]
    maxlat = lat[-1][1]
    for f in stations:
        lon.append([stations[f]['long'],f])
    lon.sort()
    minlon = lon[0][1]
    maxlon = lon[-1][1]
    return [minlat,maxlat,minlon,maxlon]
#-------------------------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    near = []
    nearma = []
    lat1 = stations[main_station]['lat']
    lon1 = stations[main_station]['long']
    for e in stations:
        lat2 = stations[e]['lat']
        lon2 = stations[e]['long']
        d = distance(lat1,lon1,lat2,lon2)
        near.append([d,e])
    near.sort()
    if K > len(stations):
        K = len(stations)-1
    for i in range (1,K+1):
        nearma.append(near[i][1])
    return nearma
#-------------------------------------------------------------------
def average_temp(stations, names):
    s = 0
    n = 0
    for e in stations:
        if e in names:
            s +=  stations[e]['temp']
            n += 1
    av = s/n
    return av
# --------------------------------------------------
# 6330188821 (29.49) 48 (2021-03-29 22:07)

def approx_match(stations, name):
    a=[]
    x=""
    for c in name:
        if c != " ":
          x += c.upper()

    for y in stations:
        z = ""
        for c in y:
            if c != "":
                z += c.upper()
        if x in z:
           a.append(y)

    return a
def top_k_min_temp_stations(stations, K):
    a = []
    for x in stations:
        if len(a) >= K:
            for i in range(len(a)):
                if [stations[x]["temp"],x] < a[i]:
                    a.insert(i, [stations[x]["temp"], x])
                    a.pop(-1)
                break
        else:
            a.append([stations[x]["temp"],x])
            a.sort()

    for i in range(len(a)):
          a[i]=a[i][1]

    return  a
def top_k_max_temp_stations(stations, K):
    a = []
    for x in stations:
        if len(a) >= K:
            for i in range(len(a)):
                if [-stations[x]["temp"],x] < a[i]:
                    a.insert(i, [-stations[x]["temp"], x])
                    a.pop(-1)
                break
        else:
            a.append([-stations[x]["temp"],x])
            a.sort()

    for i in range(len(a)):
          a[i]=a[i][1]

    return  a
def peak_stations(stations):
    a = []
    for x in stations:
        if len(a) != 0:
            if [stations[x]['lat'], x] < a[0]:
                a[0] = [stations[x]['lat'], x]
            if [stations[x]['lat'], x] > a[1]:
                a[1] = [stations[x]['lat'], x]
            if [stations[x]['long'], x] < a[2]:
                a[2] = [stations[x]['long'], x]
            if [stations[x]['long'], x] > a[3]:
                a[3] = [stations[x]['long'], x]
        else :
            a = [[stations[x]['lat'], x], [stations[x]['lat'], x], [stations[x]['long'], x], [stations[x]['long'], x]]

    for i in range(len(a)):
        a[i] = a[i][1]

    return a
def k_nearby_stations(stations, main_station, K):
    r = []
    for k in stations:
        if k != main_station:
            if len(r) >= K:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                for i in range(len(r)):
                    if [d, k] < r[i]:
                        r.insert(i, [d, k])
                        r.pop(-1)
                        break
            else:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                r.append([d, k])
                r.sort()


    for i in range(len(r)):
        r[i] = r[i][1]

    return r

    for i in range(len(r)):
        r[i] = r[i][1]

    return r
def average_temp(stations, names):
    j = 0
    x = 0
    for a in names:
        j=j+1
        x += stations[a]["temp"]

    T = x/j

    return T




# --------------------------------------------------
# 6330189421 (30) 49 (2021-03-28 02:06)

def approx_match(stations, name):
    x=""
    ans=[]
    for i in name.upper() :
        if i.isalnum() == True:
            x+=i
    for e in stations:
        if x in e.upper() :
            ans.append(e)
    return ans
def top_k_min_temp_stations(stations, K):
    x=[]
    y=[]
    for e in stations:
        x.append([stations[e]["temp"],e])
    x.sort()
    for i in x :
        y.append(i[1])
    return y[:K]
def top_k_max_temp_stations(stations, K):
    x=[]
    y=[]
    for e in stations:
        x.append([-stations[e]["temp"],e])
    x.sort()
    for i in x :
        y.append(i[1])
    return y[:K]
def peak_stations(stations):
    x=[]
    y=[]
    z=[]
    for e in stations:
        x.append([stations[e]["lat"],e])
        y.append([stations[e]["long"],e])
    x.sort()
    y.sort()
    z.append(x[0][1])
    z.append(x[-1][1])
    z.append(y[0][1])
    z.append(y[-1][1])
    return z
def k_nearby_stations(stations, main_station, K):
    lat1=stations[main_station]["lat"]
    long1=stations[main_station]["long"]
    x=[]
    y=[]
    for e in stations:
        x.append([distance(lat1, long1, stations[e]["lat"], stations[e]["long"]),e])
        x.sort()
    for i in x :
        y.append(i[1])
    y=y[1:]
    return y[:K]
def average_temp(stations, names):
    sum=0
    for i in names:
        sum+= stations[i]["temp"]
    avg=sum/len(names)
    return avg


# --------------------------------------------------
# 6330190021 (30) 50 (2021-03-28 15:37)

def approx_match(stations, name) :
    Name = ''.join(name.split()).upper()
    name_list = []
    for e in stations :
        if (''.join(e.split()).upper()).find(Name) > -1 :
            name_list.append(e)
    return name_list
def top_k_min_temp_stations(stations, K) :
    info = []
    for e in stations :
        info.append([stations[e]['temp'],e])
    info.sort()
    stations_list = []
    for i in range(min(K,len(info))) :
        stations_list.append(info[i][1])
    return stations_list
def top_k_max_temp_stations(stations, K) :
    info = []
    for e in stations :
        info.append([-stations[e]['temp'],e])
    info.sort()
    stations_list = []
    for i in range(min(K,len(info))) :
        stations_list.append(info[i][1])
    return stations_list
def peak_stations(stations) :
    lat_all, long_all = [], []
    for e in stations :
        lat_all.append([stations[e]['lat'],e])
        long_all.append([stations[e]['long'],e])
    lat_all.sort()
    long_all.sort()
    lat_min, long_min = lat_all[0][1], long_all[0][1]
    lat_max, long_max = lat_all[-1][1], long_all[-1][1]
    return [lat_min,lat_max,long_min,long_max]
def k_nearby_stations(stations, main_station, K) :
    info_list = []
    lat_0, long_0 = stations[main_station]['lat'], stations[main_station]['long']
    for e in stations :
        lat_1, long_1 = stations[e]['lat'], stations[e]['long']
        Distance = distance(lat_0,long_0,lat_1,long_1)
        info_list.append([Distance,e])
    info_list.sort()
    distance_list = []
    for i in range(1,min(K+1,len(info_list)+1)) :
        distance_list.append(info_list[i][1])
    return distance_list
def average_temp(stations, names) :
    total_temp = 0
    for e in names :
        total_temp += stations[e]['temp']
    avg_temp = total_temp/len(names)
    return avg_temp

# --------------------------------------------------
# 6330191621 (25.98) 51 (2021-03-29 21:08)

def approx_match(stations, name):
    namelst = stations.keys()
    matched = []
    for item in namelst:
        item = item.upper()
        name = name.upper()
        if name in item :
            matched.append(item)
    return matched
def top_k_min_temp_stations(stations, K):
    stations_temp = {x:stations[x]['temp'] for x in stations}
    stations_temp = sorted(stations_temp.items(),key=lambda x: x[1],reverse = False)
    mintemplst = list(stations_temp)
    names = []
    for x in mintemplst:
        names.append(x[0])
    if len(names) < K:
        return names
    else:
        names = names[:K]
    return names
def top_k_max_temp_stations(stations, K):
    stations_temp = {x:stations[x]['temp'] for x in stations}
    stations_temp = sorted(stations_temp.items(),key=lambda x: x[1],reverse = True)
    mintemplst = list(stations_temp)
    names = []
    for x in mintemplst:
        names.append(x[0])
    if len(names) < K:
        return names
    else:
        names = names[:K]
    return names
def peak_stations(stations):
    list = []
    latdict = {x:stations[x]['lat'] for x in stations}
    longdict = {x:stations[x]['long'] for x in stations}
    list.append(min(latdict, key=latdict.get))
    list.append(max(latdict, key=latdict.get))
    list.append(min(longdict, key=longdict.get))
    list.append(max(longdict, key=longdict.get))
    return list
def k_nearby_stations(stations, main_station, K):
    x = {item:distance(stations[main_station]['lat'],stations[main_station]['long'],stations[item]['lat'],stations[item]['long']) for item in stations}
    x = sorted(x.items(), key=lambda x: x[1], reverse=False)
    nearlst = list(x)
    names = []
    for x in nearlst:
        names.append(x[0])
    if len(names) < K:
        return names
    else:
        names = names[1:K+1]
    return names
def average_temp(stations, names):
    a = 0.0
    n = 0
    for x in stations:
        if x in names:
            a += float(stations[x]['temp'])
            n += 1
    average = a/n
    return average





# --------------------------------------------------
# 6330192221 (30) 52 (2021-03-29 23:38)

def approx_match(stations, name):
    s=""
    l=[]
    for c in name:
        if c!=' ':
            s+=c
            s=s.upper()
    for e in stations.keys():
        if s in e:
            l.append(e)
    return l
def top_k_min_temp_stations(stations, K):
    l=[]
    o=[]
    for n,n_info in stations.items():
        for key in n_info:
            if key=='temp':
                l.append([stations[n]['temp'],n])
                l.sort()
    for i in range(K):
        o.append(l[i][1])
    return o
def top_k_max_temp_stations(stations, K):
    l=[]
    o=[]
    for n,n_info in stations.items():
        for key in n_info:
            if key=='temp':
                l.append([-stations[n]['temp'],n])
                l.sort()
    for i in range(K):
        o.append(l[i][1])
    return o
def peak_stations(stations):
    l=[]
    o=[]
    for n,n_info in stations.items():
        for key in n_info:
            if key=='lat':
                l.append([-stations[n]['lat'],n])
                l.sort()
    o.append(l[-1][1])  #min lat
    o.append(l[0][1])   #max lat
    m=[]
    for n,n_info in stations.items():
        for key in n_info:
            if key=='long':
                m.append([-stations[n]['long'],n])
                m.sort()
    o.append(m[-1][1])  #min long
    o.append(m[0][1])   #max long
    return o
def k_nearby_stations(stations, main_station, K):
    d=0
    l=[]
    o=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for n,n_info in stations.items():
        for key in n_info:
            if key=='lat':
                lat2=n_info[key]
            if key=='long':
                long2=n_info[key]
        d=distance(lat1,long1,lat2,long2)
        l.append([d,n])
        l.sort()
    for i in range(K):
        o.append(l[i+1][1])

    return o
def average_temp(stations, names):
    a=0
    for c in names:
        a+=stations[c]['temp']
    a=a/len(names)
    return a



# --------------------------------------------------
# 6330193921 (29.6) 53 (2021-03-28 22:38)

def approx_match(stations, name):
    name2 = ''
    match = []
    for ch in name:
        if 'A' <= ch.upper() <= 'Z':
            name2 += ch.upper()
    for k in stations:
        if name2 in k:
            match.append(k.upper())
    return match
def top_k_min_temp_stations(stations, K):
    list_sta = []
    min_k = []
    for k in stations:
        list_sta.append([stations[k]['temp'],k])
    list_sta.sort()
    for e in list_sta[:K]:
        min_k.append(e[1])
    return min_k
def top_k_max_temp_stations(stations, K):
    list_sta = []
    max_k = []
    for k in stations:
        list_sta.append([-stations[k]['temp'],k])
    list_sta.sort()
    for e in list_sta[:K]:
        max_k.append(e[1])
    return max_k
def peak_stations(stations):
    list_long = []
    list_lat = []
    for k in stations:
        list_long.append([stations[k]['long'],k])
        list_lat.append([stations[k]['lat'],k])
    list_long.sort()
    list_lat.sort()
    return list_lat[0][1],list_lat[-1][1],list_long[0][1],list_long[-1][1]
def k_nearby_stations(stations, main_station, K):
    list_distance = []
    closet = []
    for k in stations:
        s = distance(stations[k]['lat'],stations[k]['long'],stations[main_station]['lat'],stations[main_station]['long'])
        list_distance.append([s,k])
    list_distance.sort()
    for e in list_distance[1:K+1]:
        closet.append(e[1])
    return closet
def average_temp(stations, names):
    every = 0
    for e in names:
        every += stations[e]['temp']
    avr = every/len(names)
    return avr

# --------------------------------------------------
# 6330194521 (30) 54 (2021-03-29 23:53)

def approx_match(stations, name):
    pro = []
    name = name.upper()
    res = ''
    for i in name:
        if i == ' ':
            res += ''
        else:
            res += i
    for j in stations:
        if res in j.upper().replace(' ',''):
            pro.append(j)
        else:
            k = j.split()
            k = ''.join(j)
            k = k.upper()
            if res in k:
                pro.append(j)
    return pro
def top_k_min_temp_stations(stations, K):
    K = min(len(stations), K)
    stations_need = sorted([[i, stations[i]['temp']] for i in stations])
    stations_need = sorted([[i[1], i[0]]for i in stations_need])
    stations_need = [[i[1], i[0]]for i in stations_need]
    return [i[0] for i in stations_need[:K]]
def top_k_max_temp_stations(stations, K):
    K = min(len(stations), K)
    stations_need = sorted([[i, -stations[i]['temp']] for i in stations])
    stations_need = sorted([[i[1], i[0]]for i in stations_need])
    stations_need = [[i[1], -i[0]]for i in stations_need]
    return [i[0] for i in stations_need[:K]]
def peak_stations(stations):
    pos_lat = []
    pos_long = []
    for i in stations:
        pos_lat.append([stations[i]['lat'],i])
    pos_lat.sort()
    for j in stations:
        pos_long.append([stations[j]['long'],j])
    pos_long.sort()
    lat_min,long_min = pos_lat[0][1],pos_long[0][1]
    lat_max,long_max = pos_lat[-1][1],pos_long[-1][1]
    return [lat_min,lat_max,long_min,long_max]
def k_nearby_stations(stations, main_station, K):
    info = []
    dis_list = []
    lat_1,long_1 = stations[main_station.upper()]['lat'],stations[main_station.upper()]['long']
    for i in stations:
        lat_2 = stations[i]['lat']
        long_2 = stations[i]['long']
        dis = distance(lat_1,long_1,lat_2,long_2)
        info.append([dis,i])
    info = sorted(info)
    for j in info:
        dis_list.append(j[1])
    return dis_list[1:min(len(stations),K+1)]
def average_temp(stations, names):
    summ = 0
    for i in names:
        if stations[i]['temp'] == 'null' or 'Null':
            summ += 0
        summ += stations[i]['temp']
    average = summ / len(names)
    return average

# --------------------------------------------------
# 6330197421 (30) 55 (2021-03-27 22:37)

def approx_match(stations, name):
    name = name.upper().split()
    name = "".join(name)
    match = []
    for station in stations:
        if name in station.upper():
            match.append(station)
    return match
def top_k_min_temp_stations(stations, K):
    temp_and_stations = []
    for station in stations:
        temp_and_stations.append([stations[station]["temp"], station])
    temp_and_stations.sort()
    k_min_temp_and_stations = temp_and_stations[:K]
    k_min_temp_stations = []
    for temp_and_stations in k_min_temp_and_stations:
        k_min_temp_stations.append(temp_and_stations[1])
    return k_min_temp_stations
def top_k_max_temp_stations(stations, K):
    temp_and_stations = []
    for station in stations:
        temp_and_stations.append([-stations[station]["temp"], station])
    temp_and_stations.sort()
    k_max_temp_and_stations = temp_and_stations[:K]
    k_max_temp_stations = []
    for temp_and_stations in k_max_temp_and_stations:
        k_max_temp_stations.append(temp_and_stations[1])
    return k_max_temp_stations
def peak_stations(stations):
    lats = []
    longs = []
    for station in stations:
        lats.append([stations[station]["lat"], station])
        longs.append([stations[station]["long"], station])
    lats.sort()
    longs.sort()
    answer = [lats[0][1], lats[-1][1], longs[0][1], longs[-1][1]]
    return answer
def k_nearby_stations(stations, main_station, K):
    distance_and_stations = []
    for station in stations:
        distance_and_stations.append([distance(stations[station]["lat"], stations[station]["long"], stations[main_station]["lat"], stations[main_station]["long"]), station])
    distance_and_stations.sort()
    k_distance_and_stations = distance_and_stations[1:K+1]
    k_nearby = []
    for distance_and_station in k_distance_and_stations:
        k_nearby.append(distance_and_station[1])
    return k_nearby
def average_temp(stations, names):
    s = 0
    for station in stations:
        if station in names:
            s += stations[station]["temp"]
    average = s/len(names)
    return average

# --------------------------------------------------
# 6330198021 (30) 56 (2021-03-29 19:38)

def approx_match(stations, name):
    x = ''
    output = []
    for e in name:
        if e.upper() in ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']:
            x += e.upper()
        else:
            x += ''
    for f in stations:
        if x in f:
            output.append(str(f))
        else:
            pass

    return output
def top_k_min_temp_stations(stations, K):
    x = {}
    y = []
    output = []

    for e in stations:
        x[e] = stations[e]['temp']
    x = dict(sorted(x.items(), key=lambda item: item[1]))

    for f in x:
        y.append(f)

    for g in y[:K:]:
        output.append(g)

    return output
def top_k_max_temp_stations(stations, K):
    x = {}
    y = []
    output = []

    for e in stations:
        x[e] = (-1)*stations[e]['temp']
    x = dict(sorted(x.items(), key=lambda item: item[1]))

    for f in x:
        y.append(f)

    for g in y[:K:]:
        output.append(g)

    return output
def peak_stations(stations):
    x = []
    X = {}
    y = []
    Y = {}
    output = []
    for e in stations:
        X[e] = stations[e]['lat']
    X = dict(sorted(X.items(), key=lambda item: item[1]))

    for f in X:
        x.append(f)

    output.append(x[0])
    output.append(x[-1])

    for e in stations:
        Y[e] = stations[e]['long']
    Y = dict(sorted(Y.items(), key=lambda item: item[1]))

    for f in Y:
        y.append(f)

    output.append(y[0])
    output.append(y[-1])

    return output
def k_nearby_stations(stations, main_station, K):
    x = {}
    y = []
    output = []
    for e in stations:
        d = abs(distance(stations[e]['lat'],stations[e]['long'],stations[main_station]['lat'],stations[main_station]['long']))
        x[d] = e

    for f in x:
        y.append([f,x[f]])
    y.sort()
    y = y[1:K+1]

    for g in y:
        output.append(g[1])

    return output
def average_temp(stations, names):
    Tavg = 0
    output = 0
    for e in names:
        T = stations[e]['temp']
        Tavg += float(T)
    Tavg = Tavg/len(names)
    output += Tavg

    return output

# --------------------------------------------------
# 6330199721 (28.5) 57 (2021-03-29 17:41)

def approx_match(stations, name):
    x = []
    z = ''
    name = name.upper()
    for i in name:
        if i!= ' ':
            z += i
    for i in stations:
        if z in i :
            x.append(i)
    return x
def top_k_min_temp_stations(stations, K):
    x = []
    y = []
    for i in stations:
        z = stations[i]['temp']
        x.append([z,i])
    x.sort()
    x = x[0:K]
    for i in x:
        y.append(i[1])
    return y
def top_k_max_temp_stations(stations, K):
    x = []
    y = []
    for i in stations:
        z = stations[i]['temp']
        x.append([z,i])
    x.sort()
    x = x[-K:]
    for i in x:
        y.append(i[1])
    return y
def peak_stations(stations):
    lat = []
    for i in stations:
        z = stations[i]['lat']
        lat.append([z,i])
        lat.sort()
    lon = []
    for i in stations:
        z = stations[i]['long']
        lon.append([z,i])
        lon.sort()
    return [lat[0][1],lat[-1][1],lon[0][1],lon[-1][1]]
def k_nearby_stations(stations, main_station, K):
    x = []
    for i in stations:
        if i != main_station:
            different = distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long'])
            x.append([different ,i])
    x.sort()
    x = x[:K]
    y = []
    for i in x:
        y.append(i[1])
    return y
def average_temp(stations, names):
    x = 0
    n = 0
    for i in names:
        if i in stations:
            x += stations[i]["temp"]
            n += 1
    avg = x/n
    return avg

# --------------------------------------------------
# 6330200621 (30) 58 (2021-03-29 01:19)

def approx_match(stations, name):
    nnnn = ''
    a = []
    name = name.strip().upper()
    for e in name:
        if e != ' ':
            nnnn += e

    for n in stations:
        if nnnn in n:
            a.append(n)
    return a
def top_k_min_temp_stations(stations, K):
    topn = []
    for e in stations:
        x = stations[e]['temp']
        topn.append([x,e])
        topn.sort()
    tmin = topn[0:K]
    stk = []
    for e in tmin:
        doi = e[1]
        stk.append(doi)
    return stk
def top_k_max_temp_stations(stations, K):
    topx = []
    for e in stations:
        x = -stations[e]['temp']
        topx.append([x,e])
        topx.sort()
    tmax = topx[0:K]
    sxk = []
    for e in tmax:
        doi = e[1]
        sxk.append(doi)
    return sxk
def peak_stations(stations):
    topk = []
    for e in stations:
        x = stations[e]['lat']
        topk.append([x,e])
        topk.sort()

    topg = []
    for e in stations:
        x = stations[e]['long']
        topg.append([x,e])
        topg.sort()

    pe = topk[0],topk[-1],topg[0],topg[-1]
    peak = []
    for e in pe:
       p = e[1]
       peak.append(p)
    return peak
def k_nearby_stations(stations, main_station, K):
    p = []
    for s in stations:
        if s != main_station:
            different = distance(stations[s]['lat'],stations[s]['long'],stations[main_station]['lat'],stations[main_station]['long'])
            p.append([different ,s])
    return [e[1] for e in sorted(p)][:K]
def average_temp(stations, names):
    i = 0
    if names == []:
        return 0
    s = 0 ;
    for province in names:
        if province in stations:
            s += stations[province]['temp']
            i += 1
    return s / i


# --------------------------------------------------
# 6330202921 (27.54) 59 (2021-03-29 22:15)

def approx_match(stations, name):
    l = []
    for station in stations:
        t = True
        for n in name.split():
            if n.upper() not in station:
               t = False
               break
        if t:
            l.append(station)
    return l
def top_k_min_temp_stations(stations, K):
    l = []
    dt = []
    for station in stations:
        dt.append([stations[station]['temp'],station])
    dt.sort()
    for i in range(0,K):
        if len(dt)==i:
            break
        else:
            l.append(dt[i][1])
    return l
def top_k_max_temp_stations(stations, K):
    l = []
    dt = []
    for station in stations:
        dt.append([stations[station]['temp'],station])
    dt.sort()
    dt = dt[::-1]
    for i in range(0,K):
        if len(dt)==i:
            break
        else:
            l.append(dt[i][1])
    return l
def peak_stations(stations):
    ladt = []
    lodt = []
    for station in stations:
        ladt.append([stations[station]['lat'],station])
        lodt.append([stations[station]['long'],station])
    ladt.sort()
    lodt.sort()
    l = []
    l.append(ladt[0][1])
    l.append(ladt[-1][1])
    l.append(lodt[0][1])
    l.append(lodt[-1][1])
    return l
def k_nearby_stations(stations, main_station, K):
    l = []
    dt = []
    for station in stations:
        if station != main_station:
            dt.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[station]['lat'],stations[station]['long']),station])
    dt.sort()
    for i in range(0,K):
        if len(dt)==i:
            break
        else:
            l.append(dt[i][1])
    return l
def average_temp(stations, names):
    r = 0
    c = 0
    for name in names:
        r += stations[name]['temp']
        c += 1
    return r/c

# --------------------------------------------------
# 6330203521 (30) 60 (2021-03-28 17:32)

def approx_match(stations, name):
    ans = []
    for i in name :
        if not ("a"<= i.lower() <= "z" or i == " ") :
            return []

    def stick_together(a) :
        b = ""
        for c in a :
            if "A"<= c.upper() <= "Z" :
                b += c.upper()
            else :
                b += ""
        return b

    name_new = stick_together(name)
    for i in stations :
        if name_new in stick_together(i) :
            ans.append(i)
    return ans
def top_k_min_temp_stations(stations, K):
    data = []
    for c in stations :
        data.append([stations[c]["temp"],c])
    data.sort()
    ans = []
    for a in data[0:K] :
        ans.append(a[1])
    return ans
def top_k_max_temp_stations(stations, K):
    data = []
    for c in stations :
        data.append([(-1)*(stations[c]["temp"]),c])
    data.sort()
    ans = []
    for a in data[0:K] :
        ans.append(a[1])
    return ans
def peak_stations(stations):
    data_lat = []
    data_long = []
    data_lat2 = []
    data_long2 = []
    for c in stations :
        data_lat.append([stations[c]["lat"],c])
        data_long.append([stations[c]["long"],c])
    data_lat.sort()
    data_long.sort()
    min_lat = data_lat[0][1]
    min_long = data_long[0][1]
    for c in stations :
        data_lat2.append([(-1)*stations[c]["lat"],c])
        data_long2.append([(-1)*stations[c]["long"],c])
    data_lat2.sort()
    data_long2.sort()
    max_lat = data_lat2[0][1]
    max_long = data_long2[0][1]
    return [min_lat,max_lat,min_long,max_long]
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    data = []
    for c in stations :
        dis = distance(stations[c]["lat"],stations[c]["long"],stations[main_station]["lat"],stations[main_station]["long"])
        data.append([dis,c])
    data.sort()
    ans = []
    for d in data[1:K+1] :   #เริ่มที่1ไม่งั้นจะรวมตัวmain_station
        ans.append(d[1])
    return ans
def average_temp(stations, names):
    num = []
    names2 = []
    for d in names :
        names2.append(d.upper())
    for c in stations :
        if c in names2 :
            num.append(float(stations[c]["temp"]))
    ans = sum(num)/len(num)
    return ans
# --------------------------------------------------
# 6330205821 (28.14) 61 (2021-03-28 17:59)

def approx_match(stations, name):
    n =name.strip().upper().split()
    nn =''
    sta = []
    for i in range(len(n)):
        nn += n[i]
    for e in stations.keys():
        if nn in e:
            sta.append(e)
    return sta
#---------------------------------------------
def top_k_min_temp_stations(stations, K):
     re_sta = []
     s = stations.keys()
     min_s = []
     for e in s:
         re_sta.append([stations[e]['temp'],e])
     re_sta.sort()
     for (x,y) in re_sta:
         min_s.append(y)
     return min_s[:K]
#-----------------------------------------------
def top_k_max_temp_stations(stations, K):
    re_sta = []
    s = stations.keys()
    max_s = []
    for e in s:
        re_sta.append([stations[e]['temp'],e])
    re_sta.sort()
    ss = re_sta[::-1]
    for (x,y) in ss:
        max_s.append(y)
    return max_s[:K]
#-------------------------------------------------
def peak_stations(stations):
    min_lat = []
    max_lat = []
    min_long =[]
    max_long =[]
    ss = []
    sss =[]
    l = []
    ll = []
    s = stations.keys()
    for e in s:
        ss.append([stations[e]['lat'],e])
        l.append([stations[e]['long'],e])
    ss.sort()
    l.sort()
    for (x,y) in ss:
        min_lat.append(y)
    sss = ss[::-1]
    ll = l[::-1]
    for (a,b) in sss:
        max_lat.append(b)
    for (c,d) in l:
        min_long.append(d)
    for (f,g) in ll:
        max_long.append(g)
    return min_lat[0], max_lat[0], min_long[0] ,max_long[0]
#--------------------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    lat_m = stations[main_station]['lat']
    long_m = stations[main_station]['long']
    close_s = []
    close =[]
    for e in stations.keys():
        lat_e = stations[e]['lat']
        long_e = stations[e]['long']
        close_s.append([distance(lat_m,long_m,lat_e,long_e), e])
    close_s.sort()
    for (x,y) in close_s:
        close.append(y)
    return close[1:K+1]
def average_temp(stations, names):
    summ =0
    for e in names:
        summ += stations[e]['temp']
    ave = summ/len(names)
    return ave

# --------------------------------------------------
# 6330206421 (25.58) 62 (2021-03-29 13:48)

def approx_match(stations, name):
    want = []
    key = name
    NEW = ""
    OP = []
    OP = key.split()
    NEW = ''.join([str(elem) for elem in OP])
    new = str(NEW)
    new = new.upper()
    for i in stations:
        if new in i:
            want.append(i)
        else :
            pass
    return want
def top_k_min_temp_stations(stations, K):
    temp = []
    for e in stations :
        temp.append(stations[e]['temp'])
    temp.sort()
    select = temp[0:K]
    use = []
    for i in select:
        if i not in use :
            use.append(i)
        else :
            pass
    mintemp = []
    tea = []
    for i in use:
        for e in stations :
            if i == float(stations[e]["temp"]):
                tea.append(e)
            else :
                pass
        tea.sort()
        for i in range(len(tea)):
            mintemp.append(tea[i])
        tea = []
    mintemp = mintemp[0:K]
    return mintemp
def top_k_max_temp_stations(stations, K):
    temp = []
    for e in stations :
        temp.append(stations[e]['temp'])
    temp.sort(reverse=True)
    select = temp[0:K]
    use = []
    for i in select:
        if i not in use :
            use.append(i)
        else :
            pass
    maxtemp = []
    tea = []
    for i in use:
        for e in stations :
            if i == float(stations[e]["temp"]):
                tea.append(e)
            else :
                pass
        tea.sort()
        for i in range(len(tea)):
            maxtemp.append(tea[i])
        tea = []
    maxtemp = maxtemp[0:K]
    return maxtemp
def peak_stations(stations):
    lat = []
    for e in stations :
        lat.append(stations[e]['lat'])
    lat.sort()
    latmin = lat[0]
    lat.sort(reverse=True)
    latmax = lat[0]
    maxlat = ""
    minlat = ""
    for e in stations :
            if latmax == stations[e]["lat"]:
                maxlat = e
            else :
                pass
    for e in stations :
            if latmin == stations[e]["lat"]:
                minlat = e
            else :
                pass

    long = []
    for e in stations :
            long.append(stations[e]['long'])
    long.sort()
    longmin = long[0]
    long.sort(reverse=True)
    longmax = long[0]
    maxlong = ""
    minlong = ""
    for e in stations :
            if longmax == stations[e]["long"]:
                maxlong = e
            else :
                pass
    for e in stations :
            if longmin == stations[e]["long"]:
                minlong = e
            else :
                pass
    return minlat,maxlat,minlong,maxlong
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]["lat"]
    long1 = stations[main_station]["long"]
    dis = []
    for e in stations :
            lat2 = stations[e]["lat"]
            long2 = stations[e]["long"]
            k = distance(lat1, long1, lat2, long2)
            dis.append(k)
    dis.sort()
    select = dis[0:K]
    use = []
    for i in select:
        if i not in use :
            use.append(i)
        else :
            pass
    near = []
    tea = []
    for i in use:
        for e in stations :
                lat2 = stations[e]["lat"]
                long2 = stations[e]["long"]
                k = distance(lat1, long1, lat2, long2)
                if k == i :
                    tea.append(e)
                else :
                    pass
        tea.sort()
        for i in range(len(tea)):
            near.append(tea[i])
        tea = []
    near = near[1:K]


    return near
def average_temp(stations, names):
    temp = []
    for i in names :
        for e in stations :
                if i == e:
                    temp.append(stations[e]['temp'])
                else :
                    pass
    sum_num = 0
    for t in temp:
        sum_num = sum_num + t
    avg = sum_num / len(temp)

    return avg


# --------------------------------------------------
# 6330208721 (30) 63 (2021-03-27 23:28)

def approx_match(stations, name):
    name2 = ''
    a = []
    name = name.upper()
    for i in name:
        if i in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" :
            name2 += i
    for k in stations:
        if name2 in k:
            a.append(k)
    return a
def top_k_min_temp_stations(stations, K):
    t = []
    a = []
    for k in stations:
        t.append([stations[k]["temp"],k])
    t.sort()
    if K > len(t):
        K = len(t)
    for i in t[:K]:
        a.append(i[1])
    return a
def top_k_max_temp_stations(stations, K):
    t = []
    a = []
    for k in stations:
        t.append([(-1)*stations[k]["temp"],k])
    t.sort()
    if K > len(t):
        K = len(t)
    for i in t[:K]:
        a.append(i[1])
    return a
def peak_stations(stations):
    la = []
    long = []
    a = []
    for k in stations:
        la.append([stations[k]["lat"],k])
        long.append([stations[k]["long"],k])
    la.sort()
    long.sort()
    a = [la[0][1],la[-1][1],long[0][1],long[-1][1]]
    return a
def k_nearby_stations(stations, main_station, K):
    lalong = []
    dist = []
    a = []
    for k in stations:
        lalong.append([stations[k]["lat"],stations[k]["long"],k])
    lalongx = [stations[main_station.upper()]["lat"],stations[main_station.upper()]["long"]]
    for i in lalong:
        dist.append([distance(lalongx[0],lalongx[1],i[0],i[1]),i[2]])
    dist.sort()
    if K+1 > len(dist):
        K = len(dist)-1
    for i in dist[1:K+1]:
        a.append(i[1])
    return a
def average_temp(stations, names):
    for i in names:
        i = i.upper()
    a = []
    for i in names:
        a.append(stations[i]["temp"])
    return sum(a)/len(names)



# --------------------------------------------------
# 6330209321 (30) 64 (2021-03-29 18:25)

def approx_match(stations, name):
    match = []
    formatName = "" # thani
    for i in name:
        if i != " ":
            formatName += i.lower()

    for i in stations:
        formatStation = "" # maehongson
        for j in i: # i = "MAE HONG SON"
            if j != " ":
                formatStation += j.lower()
        if formatName in formatStation:
            match.append(i)
    return match
def top_k_min_temp_stations(stations, K):
    stationTemp = {}
    for i in stations:
        stationTemp[i] = stations[i]['temp']

    allTemp = []
    for i in stationTemp:
        if stationTemp[i] not in allTemp:
            allTemp.append(stationTemp[i])
    allTemp.sort()

    a = 0
    minTemp = []
    while K > 0:
        sameTempStation = []
        for i in stationTemp:
            if stationTemp[i] == allTemp[a]:
                sameTempStation.append(i)
        sameTempStation.sort()
        for i in sameTempStation:
            minTemp.append(i)
            K-=1
            if K == 0:
                break
        a+=1

    return minTemp
def top_k_max_temp_stations(stations, K):
    stationTemp = {}
    for i in stations:
        stationTemp[i] = stations[i]['temp']

    allTemp = []
    for i in stationTemp:
        if stationTemp[i] not in allTemp:
            allTemp.append(stationTemp[i])
    allTemp.sort(reverse=True)
    a = 0
    minTemp = []
    while K > 0:
        sameTempStation = []
        for i in stationTemp:
            if stationTemp[i] == allTemp[a]:
                sameTempStation.append(i)
        sameTempStation.sort()
        for i in sameTempStation:
            minTemp.append(i)
            K-=1
            if K == 0:
                break
        a+=1

    return minTemp
def peak_stations(stations):
    maxLat = ['',0]
    maxLong = ['',0]
    minLat = ['',1000]
    minLong = ['',1000]

    for i in stations:
        if stations[i]['lat'] > maxLat[1]:
            maxLat[1] = stations[i]['lat']
            maxLat[0] = i
        if stations[i]['long'] > maxLong[1]:
            maxLong[1] = stations[i]['long']
            maxLong[0] = i
        if stations[i]['lat'] < minLat[1]:
            minLat[1] = stations[i]['lat']
            minLat[0] = i
        if stations[i]['long'] < minLong[1]:
            minLong[1] = stations[i]['long']
            minLong[0] = i

    return [minLat[0],maxLat[0],minLong[0],maxLong[0]]
def k_nearby_stations(stations, main_station, K):
    mainLat = stations[main_station]['lat']
    mainLong = stations[main_station]['long']

    stationDis = {}
    for i in stations:
        if i != main_station:
            stationDis[i] = distance(mainLat,mainLong,stations[i]['lat'],stations[i]['long'])

    allDis = []
    for i in stationDis:
        if stationDis[i] not in allDis:
            allDis.append(stationDis[i])
    allDis.sort()
    # print(stationDis)
    a = 0
    minDis = []
    while K > 0:
        sameDistance = []
        for i in stationDis:
            if stationDis[i] == allDis[a]:
                sameDistance.append(i)
        sameDistance.sort()
        for i in sameDistance:
            minDis.append(i)
            K -= 1
            if K == 0:
                break
        a += 1

    return minDis
def average_temp(stations, names):
    stationTemp = {}
    for i in stations:
        stationTemp[i] = stations[i]['temp']

    totalTemp = 0
    for i in names:
        totalTemp += stationTemp[i]

    return totalTemp/len(names)

# --------------------------------------------------
# 6330210921 (30) 65 (2021-03-29 18:05)

def approx_match(stations,name) :
    l = []
    for e in stations :
        if just_2up(name) in just_2up(e) : l.append(e)
    return l
def top_k_min_temp_stations(stations,K) :
    l = []
    t_n = temp_name(stations)
    t_n.sort()
    if len(stations) >= K :
        for i in range(K) :
            l.append(t_n[i][1])
    else :
        for e in t_n :
            l.append(e[1])
    return l
def top_k_max_temp_stations(stations,K) :
    l = []
    t_n = temp_name(stations)
    for i in range(len(t_n)) :
        t_n[i] = [ t_n[i][0] * -1 , t_n[i][1] ]
    t_n.sort()
    if len(stations) >= K :
        for i in range(K) :
            l.append(t_n[i][1])
    else :
        for e in t_n :
            l.append(e[1])
    return l
def peak_stations(stations) :
    lat_n = lat_name(stations)
    long_n = long_name(stations)
    lat_n.sort()
    long_n.sort()
    return [lat_n[0][1],lat_n[-1][1],\
            long_n[0][1],long_n[-1][1]]
def k_nearby_stations(stations, main_station, K):
    l = []
    d_n = dis_name(stations,main_station)
    d_n.sort()
    if len(d_n) >= K :
        for i in range(K) :
            l.append(d_n[i][1])
    else :
        for e in d_n :
            l.append(e[1])
    return l
def average_temp(stations, names):
    sum = 0
    for e in names :
        sum += stations[e]["temp"]
    return sum/len(names)

# --------------------------------------------------
def just_2up(keys) :
    s = ""
    for e in keys :
        if "a" <= e <= "z" : s += e.upper()
        elif "A" <= e <= "Z" : s+= e
        elif e != " " : s += e
    return s
def temp_name(stations) :
    temp_name = []
    for e in stations :
        temp = stations[e]["temp"]
        temp_name.append([temp,e])
    return temp_name
def lat_name(stations) :
    l = []
    for e in stations :
        l.append([stations[e]["lat"],e])
    return l
def long_name(stations) :
    l = []
    for e in stations :
        l.append([stations[e]["long"],e])
    return l
def dis_name(stations,main_station) :
    l = []
    lat1 = stations[main_station]["lat"]
    long1 = stations[main_station]["long"]
    for e in stations :
        if e != main_station :
            lat2 = stations[e]["lat"]
            long2 = stations[e]["long"]
            dis = distance(lat1,long1,lat2,long2)
            l.append([dis,e])
    return l

# --------------------------------------------------
# 6330211521 (21.48) 66 (2021-03-29 15:09)

def approx_match(stations, name):
#stations[name] = {'lat': lat, 'long': long, 'temp': temp}
    name = name.upper()
    name1 = ''
    names = []
    for i in name:
        if i == ' ':
            name1 += ''
        else :
            name1 += i
    for i in stations :
       if name1 in i :
           names += [i]
    return names
def top_k_min_temp_stations(stations, K):
    #stations[name] = {'lat': lat, 'long': long, 'temp': temp}
    t = []
    t1 = []
    t2 = []
    for i in stations :
        t += [[stations[i]['temp'], i]]
    t.sort()
    for i in range(len(t)):
        if t[i][0] not in t1 :
            t1 += [t[i][0]]
            t2 += [t[i][1]]
    t3 = t2[:K]
    return t3
def top_k_max_temp_stations(stations, K):
    t = []
    t1 = []
    t2 = []
    for i in stations :
        t += [[stations[i]['temp'], i]]
    t.sort()
    for i in range(len(t)) :
       if t[i][0] not in t1 :
            t1 += [t[i][0]]
            t2 += [t[i][1]]
    t3 = t2[-K:]
    return t3
def peak_stations(stations):
    #stations[name] = {'lat': lat, 'long': long, 'temp': temp}
    a = []
    t = []
    t1 = []
    t2 = []
    t3 = []
    for i in stations :
        t += [[stations[i]['lat'], i]]
    t.sort()
    a += [t[0][1]]
    for i in stations :
        t1 += [[stations[i]['lat'], i]]
    t1.sort()
    a += [t1[-1][1]]
    for i in stations :
        t2 += [[stations[i]['long'], i]]
    t2.sort()
    a += [t2[0][1]]
    for i in stations :
        t3 += [[stations[i]['long'], i]]
    t3.sort()
    a += [t3[-1][1]]
    return a
def k_nearby_stations(stations, main_station, K):
    t = []
    t1 = []
    t2 = []
    for i in stations :
        t += [[distance(stations[main_station]['lat'], stations[main_station]['long'], stations[i]['lat'], stations[i]['long']), i]]
    t.sort()
    for i in range(len(t)) :
       if t[i][0] not in t1 :
            t1 += [t[i][0]]
            t2 += [t[i][1]]
    t3 = t2[:K]
    return t3
def average_temp(stations, names):
    temall = 0
    for i in names :
        temall += stations[i]['temp']
    temavg = temall / len(names)
    return temavg


# --------------------------------------------------
# 6330212121 (30) 67 (2021-03-25 21:17)

def approx_match(stations, name):
    name2=''
    #list_allst=[]
    list_needst=[]
    for e in name:
        if 'A'<= e <='Z' or 'a'<= e <= 'z':
            name2+=e.upper()
    for e in stations:
        #print(e)
        if name2 in e:
            list_needst.append(e)
    #print(list_needst)
    return list_needst
def top_k_min_temp_stations(stations, K):
    st_n_temp=[]
    st=[]
    for e in stations:
        temp=stations[e]['temp']
        st_n_temp.append([temp,e])
    nl=sorted(st_n_temp,key=lambda x: (x[0],x[1]))
    #print(nl[:K])
    for i in range(K):
        st.append(nl[i][1])
    return st
def top_k_max_temp_stations(stations, K):
    st_n_temp=[]
    st=[]
    for e in stations:
        temp=stations[e]['temp']
        st_n_temp.append([temp,e])
    nl=sorted(st_n_temp,key=lambda x: (-x[0],x[1]))
    #print(nl[:K])
    for i in range(K):
        st.append(nl[i][1])

    return st
def peak_stations(stations):
    want=[]
    final=[]
    latitude_st=[]
    longtitude_st=[]
    for e in stations:
        latitude=stations[e]['lat']
        latitude_st.append([latitude,e])
    latitude_st.sort()
    want.append(latitude_st[0])
    want.append(latitude_st[-1])
    for e in stations:
        longtitude=stations[e]['long']
        longtitude_st.append([longtitude,e])
    longtitude_st.sort()
    want.append(longtitude_st[0])
    want.append(longtitude_st[-1])
    for e in want:
        final.append(e[1])
    #print(want)
    #print(final)
    return final
def k_nearby_stations(stations, main_station, K):
    lt=[]
    final=[]
    main_lat=stations[main_station]['lat']
    main_long=stations[main_station]['long']
    for e in stations:
        if e!= main_station:
            elat=stations[e]['lat']
            elong=stations[e]['long']
            dt=distance(main_lat,main_long,elat,elong)
            lt.append([dt,e])
    nl=sorted(lt,key=lambda x: (x[0],x[1]))
    #print(nl)
    for i in range(K):
        final.append(nl[i][1])
    #print(final)
    return final
def average_temp(stations, names):
    sum=0
    for e in names:
        if e in stations:
            sum+=stations[e]['temp']
    return sum/len(names)




# --------------------------------------------------
# 6330213821 (30) 68 (2021-03-29 14:44)

def approx_match(stations, name):
    ans=[]
    name=name.strip().replace(' ','')
    for i in stations.keys():
        if name.upper() in i.replace(' ','').upper():
            ans.append(i)
    return ans
def top_k_min_temp_stations(stations, K):
    x=dict(sorted(stations.items(),key=lambda item :item[0]))
    s=(sorted(x.items(),key = lambda item :item[1]['temp']))[0:K]
    ans=[e[0] for e in s]
    return ans
def top_k_max_temp_stations(stations, K):
    x=dict(sorted(stations.items(),key=lambda item :item[0]))
    s=(sorted(x.items(),key = lambda item :item[1]['temp'],reverse=True))[0:K]
    ans=[e[0] for e in s]
    return ans
def peak_stations(stations):
    ans=[]
    x=dict(sorted(stations.items(),key=lambda item :item[0]))
    s=(sorted(x.items(),key =lambda item :item[1]['lat']))
    ans.append(s[0][0])
    ans.append(s[-1][0])
    s=(sorted(x.items(),key =lambda item :item[1]['long']))
    ans.append(s[0][0])
    ans.append(s[-1][0])
    return ans
def k_nearby_stations(stations, main_station, K):
    x=dict(sorted(stations.items(),key=lambda item :item[0]))
    s=(sorted(x.items(),key=lambda item :distance(item[1]['lat'],item[1]['long'],stations[main_station]['lat'],stations[main_station]['long'])))[1:K+1]
    ans=[e[0] for e in s]
    return ans
def average_temp(stations, names):
    x=[]
    for name in names :
        x.append(stations[name]['temp'])
    ans=sum(x)/len(names)
    return ans

# --------------------------------------------------
# 6330214421 (30) 69 (2021-03-27 23:22)

def approx_match(stations, name):
    k = name.strip().upper()
    s = ""
    for i in k:
        if i != " ":
            s += i
    r = []
    for i in stations:
        j = i.upper()
        if s in j:
            r.append(i)
    return r
def top_k_min_temp_stations(stations, K):
    a = []
    for i in stations:
        a.append([stations[i]["temp"],i])
    a.sort()
    b = len(a)
    c = []
    if K <= b:
        for i in range(K):
            c.append(a[i][1])
    if K > b:
        for i in a:
            c.append(i[1])
    return c
def top_k_max_temp_stations(stations, K):
    a = []
    for i in stations:
        a.append([-stations[i]["temp"],i])
    a.sort()
    b = len(a)
    c = []
    if K <= b:
        for i in range(K):
            c.append(a[i][1])
    if K > b:
        for i in a:
            c.append(i[1])
    return c
def peak_stations(stations):
    a = []
    for i in stations:
        a.append([stations[i]["lat"],i])
    a.sort()
    x1 = a[0][1]
    x2 = a[-1][1]
    b = []
    for i in stations:
        b.append([stations[i]["long"],i])
    b.sort()
    y1 = b[0][1]
    y2 = b[-1][1]
    c = []
    c.append(x1)
    c.append(x2)
    c.append(y1)
    c.append(y2)
    return c
def k_nearby_stations(stations, main_station, K):
    x1 = stations[main_station]["lat"]
    y1 = stations[main_station]["long"]
    a = []
    for i in stations:
        x2 = stations[i]["lat"]
        y2 = stations[i]["long"]
        k = distance(x1, y1, x2, y2)
        a.append([k,i])
    a.sort()
    b = len(a)
    c = []
    if K <= b:
        for i in range(K+1):
            c.append(a[i][1])
    if K > b:
        for i in a:
            c.append(i[1])
    c = c[1::]
    return c
def average_temp(stations, names):
    x = 0
    for i in names:
        x += stations[i]["temp"]
    t = x/len(names)
    return t

# --------------------------------------------------
# 6330215021 (30) 70 (2021-03-29 04:28)

def approx_match(stations, name):
    r = name.strip().upper()
    r = r.split()
    r = ''.join(r)
    d = {}
    for k in stations:
        d[''.join(k.strip().upper().split())] = k
    ans = []
    for K in d:
        if K.find(r) != -1:
            ans.append(d[K])
    return ans
def top_k_min_temp_stations(stations, K):
    r = []
    for i in stations:
        r.append([stations[i]['temp'],i])
    r.sort()
    n = []
    for e in r[:K]:
        n.append(e[1])
    return n
def top_k_max_temp_stations(stations, K):
    r = []
    for i in stations:
        r.append([-stations[i]['temp'],i])
    r.sort()
    n = []
    for e in r[:K]:
        n.append(e[1])
    return n
def peak_stations(stations):
    lat = []
    for i in stations:
        lat.append([stations[i]['lat'], i])
    lat.sort()
    long = []
    for e in stations:
        long.append([stations[e]['long'], e])
    long.sort()
    r = [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return r
def k_nearby_stations(stations, main_station, K):
    r = []
    for i in stations:
        r.append([abs(distance(stations[main_station]['lat'], stations[main_station]['long'], stations[i]['lat'],stations[i]['long'])),i])
    r.sort()
    n = []
    for e in r[1:K+1]:
        n.append(e[1])
    return n
def average_temp(stations, names):
    r = []
    for i in names:
        r.append(stations[i]['temp'])
    s = 0
    for e in r:
        s += e
    return s/(len(names))

# --------------------------------------------------
# 6330216721 (30) 71 (2021-03-29 10:22)

def approx_match(stations, name):
    """
    :type stations: dict[str, dict[str, float]]
    :type name: str
    """
    normalized_name = name.replace(" ", "").upper()
    return [n for n in stations if normalized_name in n.replace(" ", "").upper()]
def top_k_min_temp_stations(stations, K):
    """
    :type stations: dict[str, dict[str, float]]
    :type K: int
    """
    if debug_assertion: assert K > 0
    sorted_temp_name = sorted((d['temp'], n) for n, d in stations.items())
    sorted_temp = [n for t, n in sorted_temp_name]
    return sorted_temp[:K]
def top_k_max_temp_stations(stations, K):
    """
    :type stations: dict[str, dict[str, float]]
    :type K: int
    """
    if debug_assertion: assert K > 0
    sorted_temp_name = sorted(((d['temp'], n) for n, d in stations.items()), key=lambda x: (-x[0], x[1]))
    sorted_temp = [n for t, n in sorted_temp_name]
    return sorted_temp[:K]
def peak_stations(stations):
    """
    :type stations: dict[str, dict[str, float]]
    """
    lats = [(d['lat'], n) for n, d in stations.items()]
    longs = [(d['long'], n) for n, d in stations.items()]

    min_lat = min(lats, key=lambda x: x[0])[1]
    max_lat = max(lats, key=lambda x: x[0])[1]
    min_long = min(longs, key=lambda x: x[0])[1]
    max_long = max(longs, key=lambda x: x[0])[1]

    return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    """
    :type stations: dict[str, dict[str, float]]
    :type main_station: str
    :type K: int
    """
    main_data = stations[main_station]
    main_lat, main_long = main_data['lat'], main_data['long']

    sorted_distance_station = sorted(
        (distance(d['lat'], d['long'], main_lat, main_long), n)
        for n, d in stations.items()
        if n != main_station
    )
    sorted_station = [n for dist, n in sorted_distance_station]

    return sorted_station[:K]
def average_temp(stations, names):
    """
    :type stations: dict[str, dict[str, float]]
    :type names: list[str]
    """
    return sum(stations[name]['temp'] for name in names) / len(names)
# 6330217321 (30) 72 (2021-03-27 01:05)

def approx_match(stations, name):
    out = []
    name = name.upper()
    name2 = ""
    for e in name:
        if e != " ":
            name2 += e
    for e in stations:
        no = e.split()
        no = "".join(no)
        if name2 in no:
            out.append(e)
    return out
def top_k_min_temp_stations(stations, K):
    out = []
    alltemp = []
    for e in stations:
        alltemp.append([float(stations[e]["temp"]),e])
    alltemp.sort()
    for i in range (K):
        if i >= len(alltemp):
            break
        else:
            out.append(alltemp[i][1])
    return out
def top_k_max_temp_stations(stations, K):
    out = []
    alltemp = []
    for e in stations:
        alltemp.append([-float(stations[e]["temp"]),e])
    alltemp.sort()
    for i in range (K):
        if i >= len(alltemp):
            break
        else:
            out.append(alltemp[i][1])
    return out
def peak_stations(stations):
    lat_min = []
    lat_max = []
    long_min = []
    long_max = []
    for e in stations:
        lat_min.append([float(stations[e]["lat"]),e])
        lat_max.append([-float(stations[e]["lat"]),e])
        long_min.append([float(stations[e]["long"]),e])
        long_max.append([-float(stations[e]["long"]),e])
    lat_min.sort()
    lat_max.sort()
    long_min.sort()
    long_max.sort()
    out = [lat_min[0][1],lat_max[0][1],long_min[0][1],long_max[0][1]]
    return out
def k_nearby_stations(stations, main_station, K):
    out = []
    dis = []
    for e in stations:
        d = distance(float(stations[e]["lat"]),float(stations[e]["long"]),float(stations[main_station]["lat"]),float(stations[main_station]["long"]))
        dis.append([d, e])
    dis.sort()
    for i in range (1,K+1):
        if i >= len(dis):
            break
        else: out.append(dis[i][1])
    return out
def average_temp(stations, names):
    s = 0
    n = 0
    for e in names:
        s += stations[e]["temp"]
        n += 1
    return s/n
# --------------------------------------------------
# 6330219621 (28.74) 73 (2021-03-27 13:59)

def approx_match(stations, name):
    new_name = str()
    for e in name :
        if 'A' <= e.upper() <= 'Z' : new_name += e.upper()
    sta_list = list()
    for sta in stations :
        if new_name in sta :
            sta_list.append(sta)
    return sta_list
def top_k_min_temp_stations(stations, K):
    tem_list = list()
    for sta in stations :
        tem_list.append([stations[sta]['temp'],sta])
    tem_list.sort()
    tem_list = tem_list[:K]
    temp_final = list()
    for t in tem_list :
        temp_final.append(t[1])
    return temp_final
def top_k_max_temp_stations(stations, K):
    tem_list = list()
    for sta in stations :
        tem_list.append([stations[sta]['temp'],sta])
    tem_list.sort()
    tem_list = tem_list[:-K-1:-1]
    temp_final = list()
    for t in tem_list :
        temp_final.append(t[1])
    return temp_final
def peak_stations(stations):
    lat_list = list()
    long_list = list()
    for sta in stations :
        lat_list.append([stations[sta]['lat'],sta])
        long_list.append([stations[sta]['long'],sta])
    max_lat = max(lat_list)[1]
    min_lat = min(lat_list)[1]
    max_long = max(long_list)[1]
    min_long = min(long_list)[1]
    return [min_lat,max_lat,min_long,max_long]
def k_nearby_stations(stations, main_station, K):
    dis_list = list()
    for sta in stations :
        d = distance(stations[main_station.upper()]['lat'],stations[main_station.upper()]['long'], \
                     stations[sta]['lat'],stations[sta]['long'])
        dis_list.append([d,sta])
    dis_list.sort()
    dis_list = dis_list[1:K+1]
    dis_final = list()
    for ds in dis_list :
        dis_final.append(ds[1])
    return dis_final
def average_temp(stations, names):
    temp,count = 0,0
    for sta in names :
        temp += stations[sta.upper()]['temp']
        count += 1
    avg = temp / count
    return avg

# --------------------------------------------------
# 6330221821 (29.6) 74 (2021-03-27 23:24)

def approx_match(stations, name):
    c = []
    a = despace(name.upper())
    for e in stations:
        if a in despace(e):
            c.append(e)
    return c
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    for e in range(len(a)):
        b.append(a[e][1])
    return b[:K]
def top_k_max_temp_stations(stations, K):
    c = []
    d = []
    for e in stations:
        c.append([-stations[e]['temp'],e])
    c.sort()
    for e in range(len(c)):
        d.append(c[e][1])
    return d[:K]
def peak_stations(stations):
    lan = []; lax = []
    lon = []; lox = []
    for e in stations:
        lan.append([stations[e]['lat'],e])
        lax.append([-stations[e]['lat'],e])
        lon.append([stations[e]['long'],e])
        lox.append([-stations[e]['long'],e])
    lan.sort(); lax.sort(); lon.sort(); lox.sort()
    return lan[0][1], lax[0][1], lon[0][1], lox[0][1]
def k_nearby_stations(stations, main_station, K):
    s = main_station.upper()
    a,c = [],[]
    for e in stations:
        a.append([distance(stations[s]['lat'], stations[s]['long'], stations[e]['lat'], stations[e]['long']), e])
    a.sort()
    b = a[1:K+1]
    for e in b:
        c.append(e[1])
    return c
def average_temp(stations, names):
    a = 0
    for e in names:
        if e in stations:
            a += stations[e]['temp']
    return a/len(names)

# --------------------------------------------------
def despace(word):
    a = ''
    for e in word:
        if e != ' ':
            a += e
    return a
# 6330222421 (29) 75 (2021-03-28 21:43)

def approx_match(stations, name):

    a = ''
    for i in name.upper() :
        if 'A' <= i <= 'Z' :
            a += i

    b = []
    for i in stations :


        n = ''

        for e in i :
            if 'A' <= e <= 'Z' :
                n += e

        if a in n :
            b.append(i)

    return b
def top_k_min_temp_stations(stations, K):

    temp = []
    for i in stations :
        t = stations[i]['temp']
        temp.append([t, i])

    temp.sort()

    top_min = []
    for i in range(K) :
        top_min.append(temp[i][1])

    return top_min
def top_k_max_temp_stations(stations, K):

    temp = []
    for i in stations :
        t = stations[i]['temp']
        temp.append([-t, i])

    temp.sort()

    top_max = []
    for i in range(K) :
        top_max.append(temp[i][1])

    return top_max
def peak_stations(stations):

    peak = []

    lat = [] #min lat
    for i in stations :
        la = stations[i]['lat']
        lat.append([la, i])

    lat.sort()

    top_min_lat = lat[0][1]
    peak.append(top_min_lat)


    lat2 = [] #max lat
    for i in stations :
        la2 = stations[i]['lat']
        lat2.append([-la2, i])

    lat.sort()

    top_max_lat = lat2[0][1]
    peak.append(top_max_lat)


    long = [] #min long
    for i in stations :
        lo = stations[i]['long']
        long.append([lo, i])

    long.sort()

    top_min_long = long[0][1]
    peak.append(top_min_long)



    long2 = [] #max long
    for i in stations :
        lo2 = stations[i]['long']
        long2.append([-lo2, i])

    long2.sort()

    top_max_long = long2[0][1]
    peak.append(top_max_long)

    return peak
def k_nearby_stations(stations, main_station, K):

    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']

    all_distance = []

    for i in stations :

        lat2 = stations[i]['lat']
        long2 = stations[i]['long']

        x = distance(lat1, long1, lat2, long2)

        all_distance.append([x, i])

    all_distance.sort()

    min_distance = all_distance[1:K+1]

    min_K_distance = []
    for i in range(len(min_distance)) :
        a = min_distance[i][1]
        min_K_distance.append(a)


    return min_K_distance
def average_temp(stations, names):

    a = 0

    for e in names :
        temp = stations[e]['temp']
        a += temp

    x_bar = a/len(names)

    return x_bar

# --------------------------------------------------
# 6330223021 (30) 76 (2021-03-28 00:21)

def approx_match(stations, name):
    name_temp = ''.join([i.strip().upper() for i in name])
    return [i for i in stations if name_temp in ''.join([j.strip().upper() for j in i.upper()])]
def top_k_min_temp_stations(stations, K):
    return [i[1] for i in sorted([[stations[i]['temp'],i] for i in stations])[:K]]
def top_k_max_temp_stations(stations, K):
    return [i[1] for i in sorted([[-stations[i]['temp'],i] for i in stations])[:K]]
def peak_stations(stations):
    min_lat = [[stations[i]['lat'],i] for i in stations]
    max_lat = [[-stations[i]['lat'],i] for i in stations]
    min_long = [[stations[i]['long'],i] for i in stations]
    max_long = [[-stations[i]['long'],i] for i in stations]
    return [sorted(min_lat)[0][1],sorted(max_lat)[0][1],sorted(min_long)[0][1],sorted(max_long)[0][1]]
def k_nearby_stations(stations, main_station, K):
    return [i[1] for i in sorted([[distance(stations[main_station]['lat'],stations[main_station]['long'],\
        stations[i]['lat'],stations[i]['long']),i] for i in stations])[1:K+1]]
def average_temp(stations, names):
    temp = 0
    for i in names:
        temp += stations[i]['temp']
    return temp/len(names)

# --------------------------------------------------
# 6330224721 (30) 77 (2021-03-28 21:19)

def approx_match(stations, name):
    if name == "":
        return []
    stations_upper = []
    stations_original = []
    stations_out = []
    for e in stations:
        word = ""
        for k in e:
            if k != " ":
                word += k
        stations_upper.append(word.upper())
        stations_original.append(e)
    name_a = ""
    for e in name:
        if e != " ":
            name_a += e.upper()

    for e in stations_upper:
        if name_a in e:
            stations_out.append(stations_original[stations_upper.index(e)])
    return stations_out

# --------------------------------------------------
def top_k_min_temp_stations(stations, K):
    if K <= 0:
        return []
    x = []
    for e in stations:
        x.append([stations[e]['temp'],e])
    x.sort()
    stations_tempk = []
    if len(x) >= K:
        for i in range(K):
            stations_tempk.append(x[i][1])
    elif len(x) < K:
        K = len(x)
        for i in range(K):
            stations_tempk.append(x[i][1])
    return stations_tempk

# --------------------------------------------------
def top_k_max_temp_stations(stations, K):
    if K <= 0:
        return []
    x = []
    for e in stations:
        x.append([-(stations[e]['temp']),e])
    x.sort()
    stations_tempk = []
    if len(x) >= K:
        for i in range(K):
            stations_tempk.append(x[i][1])
    elif len(x) < K:
        K = len(x)
        for i in range(K):
            stations_tempk.append(x[i][1])
    return stations_tempk

# --------------------------------------------------
def peak_stations(stations):
    x = []
    y = []
    for e in stations:
        x.append([stations[e]['lat'],e])
        y.append([stations[e]['long'],e])
    x.sort()
    y.sort()
    z = [x[0][1],x[-1][1],y[0][1],y[-1][1]]
    return z

# --------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    if K <= 0:
        return []
    x = []
    for e in stations:
        if e != main_station:
            x.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[e]['lat'],stations[e]['long']),e])
    x.sort()
    result = []
    if len(x) >= K:
        for i in range(K):
            result.append(x[i][1])
    elif len(x) < K:
        K = len(x)
        for i in range(K):
            result.append(x[i][1])
    return result

# --------------------------------------------------
def average_temp(stations, names):
    x = []
    for e in names:
        x.append(stations[e]['temp'])
    s = 0.0
    for e in x:
        s += e
    ss = s/len(x)
    return ss

# --------------------------------------------------
# 6330225321 (30) 78 (2021-03-27 23:46)

def approx_match(stations, name):
    a = name.upper()
    b = ''
    c = []
    for e1 in a :
        if 'A' <= e1 <= 'Z' :
            b+=e1
    for e2 in stations :
        e3 = e2.upper()
        if b in e3 :
            c.append(e2)
    return c
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for e in stations :
        a.append([stations[e]['temp'],e])
    a.sort()
    if len(a) >= K :
        for i in range(K) :
            b.append(a[i][1])
    else :
        for i in range(len(a)) :
            b.append(a[i][1])

    return b
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for e in stations :
        a.append([-(stations[e]['temp']) , e])
    a.sort()
    if len(a) >= K :
        for i in range(K) :
            b.append(a[i][1])
    else :
        for i in range(len(a)) :
            b.append(a[i][1])
    return b
def peak_stations(stations):
    d = []
    f = []
    g = []
    for e in stations :
        d.append([stations[e]['lat'],e])
    d.sort()
    g+=[d[0][1]]
    g+=[d[-1][1]]
    for e in stations :
        f.append([stations[e]['long'],e])
    f.sort()
    g+=[f[0][1]]
    g+=[f[-1][1]]
    return g
def k_nearby_stations(stations, main_station, K):
    c = []
    f = []
    a1 = stations[main_station]['lat']
    b1 = stations[main_station]['long']
    for e in stations :
        a2 = stations[e]['lat']
        b2 = stations[e]['long']
        d = distance(a1, b1, a2, b2)
        if d >0 :
            c.append([d,e])
    c.sort()
    if len(c) >= K :
        for i in range(K) :
            f.append(c[i][1])
    else :
        for i in range(len(c)) :
            f.append(c[i][1])
    return f
def average_temp(stations, names):
    a = 0
    for e in names :
        a+= stations[e]['temp']
    b = a/len(names)
    return b

# --------------------------------------------------
# 6330226021 (30) 79 (2021-03-29 00:18)

def approx_match(stations, name):
    name = ''.join(name.upper().split())
    stations_name = []
    for s_name in stations:
        if name in ''.join(s_name.split()):
            stations_name.append(s_name)
    return stations_name
def top_k_min_temp_stations(stations, K):
    s_t = []
    for s_name in stations:
        s_t.append([stations[s_name]['temp'], s_name])
    s_t.sort()
    k_min_temp_stations = []
    if K >= len(s_t):
        for temp, name in s_t:
            k_min_temp_stations.append(name)
        return k_min_temp_stations
    else:
        for i in range(K):
            k_min_temp_stations.append(s_t[i][1])
        return k_min_temp_stations
def top_k_max_temp_stations(stations, K):
    s_t = []
    for s_name in stations:
        s_t.append([-stations[s_name]['temp'], s_name])
    s_t.sort()
    k_max_temp_stations = []
    if K >= len(s_t):
        for temp, name in s_t:
            k_max_temp_stations.append(name)
        return k_max_temp_stations
    else:
        for i in range(K):
            k_max_temp_stations.append(s_t[i][1])
        return k_max_temp_stations
def peak_stations(stations):
    all_lat = []
    all_long = []
    for n_sta in stations:
        all_lat.append([stations[n_sta]['lat'], n_sta])
        all_long.append([stations[n_sta]['long'], n_sta])
    all_lat.sort()
    all_long.sort()
    min_lat = all_lat[0][1]
    max_lat = all_lat[-1][1]
    min_long = all_long[0][1]
    max_long = all_long[-1][1]
    return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    main = [stations[main_station]['lat'], stations[main_station]['long']]
    n_distance = []
    for s_name in stations:
        n_distance.append([distance(main[0], main[1], stations[s_name]['lat'], stations[s_name]['long']), s_name])
    n_distance.sort()
    n_distance = n_distance[1::]
    k_distance = []
    if K >= len(n_distance):
        for dis, s_name in n_distance:
            k_distance.append(s_name)
        return k_distance
    else:
        for i in range(K):
            k_distance.append(n_distance[i][1])
        return k_distance
def average_temp(stations, names):
    sum_temp = 0
    for name in names:
        sum_temp += stations[name]['temp']
    avg_temp = sum_temp / len(names)
    return avg_temp

# --------------------------------------------------
# 6330227621 (30) 80 (2021-03-29 15:53)

def approx_match(stations, name):
    name=name.strip().upper().split()
    name=''.join(name)
    N=''
    nname=[]
    for e in stations:
        E=e.upper()
        if name in E:
            nname.append(e)
    return nname
#.............................................
def top_k_min_temp_stations(stations, K):
    S=[]
    for e in stations:
        S.append([stations[e]['temp'],e])
    S.sort()
    S=S[0:K:]
    N=[]
    for a,b in S:
        N.append(b)
    return N
#..............................................
def top_k_max_temp_stations(stations, K):
    S=[]
    for e in stations:
        S.append([stations[e]['temp']*(-1),e])
    S.sort()
    S=S[0:K:]
    N=[]
    for a,b in S:
        N.append(b)
    return N
#.............................................
def peak_stations(stations):
    la=[]
    lo=[]
    for e in stations:
        la.append([stations[e]['lat'],e])
        lo.append([stations[e]['long'],e])
    la.sort()
    lo.sort()
    L=[la[0][1],la[-1][1],lo[0][1],lo[-1][1]]
    return L
#...............................................
def k_nearby_stations(stations, main_station, K):
    D=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for e in stations:
        lat2=stations[e]['lat']
        long2=stations[e]['long']
        if main_station!=e:
            d=distance(lat1,long1,lat2,long2)
            D.append([d,e])
    D.sort()
    D=D[0:K:]
    A=[]
    for a,b in D:
        A.append(b)
    return A
#...............................................
def average_temp(stations, names):
    sum=0
    for e in names:
        sum+=stations[e]['temp']
    avg=sum/len(names)
    return avg
# --------------------------------------------------
# 6330228221 (28.02) 81 (2021-03-28 00:11)

def approx_match(stations, name):
    stations_key = []
    name_list = name.split()
    names = ''.join(name_list).upper()
    ans = []
    for i in stations.keys():
        stations_key.append(i)
    for i in range(len(stations_key)):
        if names in stations_key[i].upper() :
            ans.append(stations_key[i])
    return ans
def top_k_min_temp_stations(stations, K):

    stations_key = []
    temp = []
    ans = []
    for i in stations.keys():
        stations_key.append(i)
    for i in range(len(stations_key)) :
        temp.append(stations[stations_key[i]]['temp'])
    stations_temp = {}
    for i in range(len(temp)):
        stations_temp[temp[i]] = stations_key[i]
    temp.sort()
    temp_k = temp[:K]
    for i in range(len(temp_k)):
        ans.append(stations_temp[temp_k[i]])
    return ans
def top_k_max_temp_stations(stations, K):

    stations_key = []
    temp = []
    ans = []
    for i in stations.keys():
        stations_key.append(i)
    for i in range(len(stations_key)) :
        temp.append(stations[stations_key[i]]['temp'])
    stations_temp = {}
    for i in range(len(temp)):
        stations_temp[temp[i]] = stations_key[i]
    temp.sort()
    temp_k = temp[-1:-(K+1):-1]
    for i in range(len(temp_k)):
        ans.append(stations_temp[temp_k[i]])
    return ans
def peak_stations(stations):
    ans = []
    stations_key = []
    lat = []
    long = []
    for i in stations.keys():
        stations_key.append(i)
    for i in range(len(stations_key)) :
        lat.append(stations[stations_key[i]]['lat'])
        long.append(stations[stations_key[i]]['long'])
    stations_lat = {}
    stations_long = {}
    for i in range(len(lat)):
        stations_lat[lat[i]] = stations_key[i]
        stations_long[long[i]] = stations_key[i]
    lat.sort()
    long.sort()
    ans = [stations_lat[min(lat)],stations_lat[max(lat)],stations_long[min(long)],stations_long[max(long)]]
    return ans
def k_nearby_stations(stations, main_station, K):
    dis_stations = {}
    dis = []
    namestations = []
    ans = []
    for i in stations.keys():
        namestations.append(i)
    proto_lat = stations[main_station]['lat']
    proto_long = stations[main_station]['long']
    for i in range(len(namestations)):
        ex_lat = stations[namestations[i]]['lat']
        ex_long = stations[namestations[i]]['long']
        dis.append(distance(ex_lat,ex_long,proto_lat,proto_long))
        dis_stations[dis[i]] = namestations[i]
    dis.sort()
    dis_ans = dis[1:K+1:]
    for i in range(len(dis_ans)):
        ans.append(dis_stations[dis_ans[i]])
    return ans
def average_temp(stations, names):
    ans = []
    avg = 0
    count = 0
    for i in range(len(names)):
        ans.append(stations[names[i]]['temp'])
    for i in ans :
        avg+=i
        count +=1
    avg = avg/count
    return avg

# --------------------------------------------------'''
# 6330229921 (30) 82 (2021-03-28 16:21)

def approx_match(stations, name):
    a = []
    b = ''
    for e in name:
        if 'A' <= e.upper() <= 'Z':
            b += e.upper()
    for e in stations:
        if b in e:
            a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    a = []
    for e in stations:
        a.append([float(stations[e]['temp']), e])
    a.sort()
    b = []
    for e in a:
        b.append(e[1])
    return b[:K]
def top_k_max_temp_stations(stations, K):
    a = []
    for e in stations:
        a.append([-float(stations[e]['temp']), e])
    a.sort()
    b = []
    for e in a:
        b.append(e[1])
    return b[:K]
def peak_stations(stations):
    a = []
    for e in stations:
        a.append([float(stations[e]['lat']), e])
    a.sort()
    b = []
    for e in stations:
        b.append([float(stations[e]['long']), e])
    b.sort()
    return [a[0][1], a[-1][1], b[0][1], b[-1][1]]
def k_nearby_stations(stations, main_station, K):
    a = []
    for e in stations:
        if e != main_station:
            d = distance(float(stations[main_station]['lat']), float(stations[main_station]['long']), float(stations[e]['lat']), float(stations[e]['long']))
            a.append([d, e])
    a.sort()
    b = []
    for e in a:
        b.append(e[1])
    return b[:K]
def average_temp(stations, names):
    a = 0
    i = 0
    for e in names:
        if e in stations:
            a += float(stations[e]['temp'])
            i += 1
    return a/i

# --------------------------------------------------
# 6330230421 (30) 83 (2021-03-27 23:03)

def approx_match(stations, name):
    word = ''
    for i in name.upper():
        if 'A' <= i <= 'Z':
            word += i
        else:
            word += ''
    result = []
    for names in stations:
        check = names.upper()
        if word in check:
            result.append(check)
    return result
def top_k_min_temp_stations(stations, K):
    List_temp = []
    for names in stations:
        List_temp.append([stations[names]['temp'],names])
    List_temp.sort()
    result = []
    for i in range(K):
        if len(stations) > i:
            result.append(List_temp[i][1])
        else : break
    return result
def top_k_max_temp_stations(stations, K):
    List_temp = []
    for names in stations:
        List_temp.append([-stations[names]['temp'],names])
    List_temp.sort()
    result = []
    for i in range(K):
        if len(stations) > i:
            result.append(List_temp[i][1])
        else : break
    return result
def peak_stations(stations):
    lat = []
    long = []
    for names in stations:
        lat.append([stations[names]['lat'],names])
        long.append([stations[names]['long'],names])
    lat.sort()
    long.sort()
    return [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    dis2main = []
    for names in stations:
        if names != main_station:
            dis2main.append([distance(stations[names]['lat'],\
                                      stations[names]['long'],\
                                      stations[main_station]['lat'],\
                                      stations[main_station]['long']),names])
    dis2main.sort()
    result = []
    for i in range(K):
        if len(stations)-1 > i:
            result.append(dis2main[i][1])
    return result
def average_temp(stations, names):
    s = 0
    for i in range(len(names)):
        s += stations[names[i]]['temp']
    return s / len(names)

# --------------------------------------------------
# 6330232721 (28.74) 84 (2021-03-29 01:22)

def approx_match(stations, name):
    name = name.split()
    name = ''.join(name)
    name = name.upper()
    a = []
    for  e in stations:
        f = e.split()
        f = ''.join(f)
        f = f.upper()
        if name in f:
            a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    lisst = []
    for e in stations:
        a = stations[e]['temp']
        lisst.append([a,e])
    lisst.sort()
    b = []
    for e in lisst:
        b.append(e[1])
    return b[:K]
def top_k_max_temp_stations(stations, K):
    lisst = []
    for e in stations:
        a = stations[e]['temp']
        lisst.append([a,e])
    lisst.sort()
    b = []
    for e in lisst:
        b.append(e[1])
    return b[-K:][::-1]
def peak_stations(stations):
    lisst1 = []
    lisst2 = []
    Lat = []
    Long = []
    for e in stations:
        a = stations[e]['lat']
        b = stations[e]['long']
        lisst1.append([a,e])
        lisst2.append([b,e])
    lisst1.sort()
    lisst2.sort()
    for e in lisst1:
        Lat.append(e[1])
    for e in lisst2:
        Long.append(e[1])
    LatMax = Lat[-1]
    LatMin = Lat[0]
    LongMax = Long[-1]
    LongMin = Long[0]
    return [LatMin, LatMax, LongMin, LongMax]
def k_nearby_stations(stations, main_station, K):
    LatMain = stations[main_station]['lat']
    LongMain = stations[main_station]['long']
    ans = []
    newans = []
    for e in stations:
        dist = distance(LatMain,LongMain,stations[e]['lat'],stations[e]['long'])
        ans.append([dist,e])
    ans.sort()
    for e in ans:
        newans.append(e[1])
    return newans[1:K+1]
def average_temp(stations, names):
    allTemp = 0
    n = 0
    for e in stations:
        if e in names:
            allTemp += stations[e]['temp']
            n+=1
    return allTemp / n


# --------------------------------------------------
# 6330233321 (25.98) 85 (2021-03-29 21:30)

def approx_match(stations, name):

    name = name.upper()
    stanames = []
    for e in stations:
        if name in e:
            stanames.append(e)
    return stanames
def top_k_min_temp_stations(stations, K):

    nat = []
    names = []
    for e in stations:
        nat.append([stations[e]['temp'], e])
    nat.sort()
    for i in range(K):
        names.append(nat[i][1])
    return names
def top_k_max_temp_stations(stations, K):

    nat = []
    names = []
    for e in stations:
        nat.append([-stations[e]['temp'], e])
    nat.sort()
    for i in range(K):
        names.append(nat[i][1])
    return names
def peak_stations(stations):

    nac = []
    names = []
    for e in stations:
        nac.append([stations[e]['lat'], e])
    nac.sort()
    names.append(nac[0][1])
    names.append(nac[-1][1])
    nac = []
    for e in stations:
        nac.append([stations[e]['long'], e])
    nac.sort()
    names.append(nac[0][1])
    names.append(nac[-1][1])
    return names
def k_nearby_stations(stations, main_station, K):

    nad = []
    names = []
    for e in stations:
        d = ((stations[main_station]['lat']-stations[e]['lat'])**2\
             +(stations[main_station]['long']-stations[e]['long'])**2)**0.5
        nad.append([d, e])
    nad.sort()
    for i in range(K):
        names.append(nad[i+1][1])
    return names
def average_temp(stations, names):

    nat = []
    avgtemp = 0
    count = 0
    for e in stations:
        if e in names:
            nat.append([stations[e]['temp'], e])
    for e in nat:
        avgtemp += e[0]
        count += 1
    return avgtemp/count

# --------------------------------------------------
# 6330234021 (23) 86 (2021-03-29 18:10)

def approx_match(stations, name):
    x = name.upper()
    y = ''
    z = []
    for e in x :
        if 'a'<=e<='z' or 'A'<=e<='Z' :
            y += e
    for i in stations :
       if y in i :
           z.append(i)
    return z
def top_k_min_temp_stations(stations, K):
    x = []
    y = []
    for i in stations :
        x.append([stations[i]['temp'],i])
    x.sort()
    c = min(K,len(x))
    for e in range(c) :
        y.append(x[e][1])
    return y
def top_k_max_temp_stations(stations, K):
    x = []
    y = []
    for i in stations :
        x.append([-stations[i]['temp'],i])
    x.sort()
    c = min(K,len(x))
    for e in range(c) :
        y.append(x[e][1])
    return y
def peak_stations(stations):
    x = []
    y = []
    m = []
    n = []
    p = []
    for i in stations :
        y.append([stations[i]['lat'], i])
    y.sort()
    x.append(y[0][1])
    for i in stations :
        m.append([stations[i]['lat'], i])
    m.sort()
    x.append(m[-1][1])
    for i in stations :
        n.append([stations[i]['long'], i])
    m.sort()
    x.append(m[0][1])
    for i in stations :
        p.append([stations[i]['long'], i])
    p.sort()
    x.append(p[-1][1])
    return x
def k_nearby_stations(stations, main_station, K):
    x = []
    y = []
    z = []
    for i in stations :
        x += [[distance(stations[main_station]['lat'],\
                        stations[main_station]['long'],\
                        stations[i]['lat'],\
                        stations[i]['long']), i]]
    x.sort()
    for i in range(len(x)) :
       if x[i][0] not in y :
            y.append(x[i][0])
            z.append(x[i][1])
    a = z[:K]
    return a
def average_temp(stations, names):
    x = 0
    for i in names :
        x += stations[i]['temp']
    y = x / len(names)
    return y


# --------------------------------------------------
# 6330235621 (30) 87 (2021-03-28 23:08)

def approx_match(stations, name):
    a=[]
    b=alt(name)
    for e in stations :
        if b!='' :
            if b in e.upper() :
                a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    for i in stations :
        a.append([stations[i]['temp'],i])
    a.sort()
    b=[]
    c=min(K,len(a))
    for e in range(c) :
        b.append(a[e][1])
    return b
def top_k_max_temp_stations(stations, K):
    a=[]
    for i in stations :
        a.append([-stations[i]['temp'],i])
    a.sort()
    b=[]
    c=min(K,len(a))
    for e in range(c) :
        b.append(a[e][1])
    return b
def peak_stations(stations):
    a=[]
    for i in stations :
        a.append([stations[i]['lat'],i])
    a.sort()
    b=[]
    for i in stations :
        b.append([stations[i]['long'],i])
    b.sort()
    c=[]
    c.append(a[0][1])
    c.append(a[-1][1])
    c.append(b[0][1])
    c.append(b[-1][1])
    return c
def k_nearby_stations(stations, main_station, K):
    a=[]
    for i in stations :
        b=distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long'])
        a.append([b,i])
    a.sort()
    b=[]
    for e in range(len(a)) :
        if a[e][1]!=main_station :
            b.append(a[e][1])
    d=[]
    c=min(K,len(a))
    for n in range(c) :
        d.append(b[n])
    return d
def average_temp(stations, names):
    s=0
    for e in names :
        s+=stations[e]['temp']
    a=s/len(names)
    return a
# --------------------------------------------------
def alt(x) :
    a=''
    for e in x :
        if 'a'<=e<='z' or 'A'<=e<='Z' :
            a+=e.upper()
        elif e==' ' :
            pass
        else :
            a=''
            break
    return a
# 6330236221 (29.6) 88 (2021-03-28 15:14)

def approx_match(stations, name):
    a = []
    b =[]
    name = name.split()
    name = "".join(name)
    for i in stations:
        if name.lower() in i.lower():
            a.append(i)

    return a
def top_k_min_temp_stations(stations, K):
    c = 0
    a = []
    v =[]
    for i in stations:
        a.append([i,stations[i]["temp"]])
    for i in a:
        [i[0],i[1]] = [i[1],i[0]]
    a.sort()

    for i in a:
        [i[0],i[1]] = [i[1],i[0]]
    a = a[:K:]
    for i in a:
        v.append(i[0])
    return v
def top_k_max_temp_stations(stations, K):
    c = 0
    a = []
    v =[]
    for i in stations:
        a.append([i,stations[i]["temp"]])
    for i in a:
        i[1] *= -1
        [i[0],i[1]] = [i[1],i[0]]
    a.sort()

    for i in a:
        i[0] *= -1
        [i[0],i[1]] = [i[1],i[0]]
    a = a[:K:]
    for i in a:
        v.append(i[0])
    return v
def peak_stations(stations):
    a_lati = []
    a_long = []

    for i in stations:
        a_long.append([i,stations[i]["long"]])
        a_lati.append([i,stations[i]["lat"]])
    for i in a_lati:
        i[1] *= -1
        [i[0],i[1]] = [i[1],i[0]]
    for i in a_long:
        i[1] *= -1
        [i[0],i[1]] = [i[1],i[0]]
    a_lati.sort()
    a_long.sort()
    for i in a_lati:
        i[0] *= -1
        [i[0],i[1]] = [i[1],i[0]]
    for i in a_long:
        i[0] *= -1
        [i[0],i[1]] = [i[1],i[0]]
    a_lati_min = a_lati[len(a_lati)-1]
    a_lati_max = a_lati[0]
    a_long_min = a_long[len(a_long)-1]
    a_long_max = a_long[0]
    return a_lati_min[0],a_lati_max[0],a_long_min[0],a_long_max[0]
def k_nearby_stations(stations, main_station, K):
     a =[]
     v =[]
     for i in stations:
         long1 = stations[i]["long"]
         lat1 = stations[i]["lat"]
         long2 = stations[main_station]["long"]
         lat2 = stations[main_station]["lat"]
         dis = distance(lat1, long1, lat2, long2)
         a.append([i,dis])

     for i in a:
        [i[0],i[1]] = [i[1],i[0]]
     a.sort()

     for i in a:
        [i[0],i[1]] = [i[1],i[0]]
     for i in a:
         v.append(i[0])
     v = v[1:K+1]


     return v
def average_temp(stations, names):
    a = []
    b = 0
    for i in names:
        a.append(stations[i]["temp"])
    for i in a:
        b += i
    sums = b/len(a)
    return sums



# --------------------------------------------------
# 6330238521 (30) 89 (2021-03-29 16:03)

def approx_match(stations, name):
    name = name.lower()
    name = ''.join([e for e in name if e != ' '])
    L = [e for e in stations if name in ''.join([x for x in e if x != ' ']).lower()]
    return L
def top_k_min_temp_stations(stations, K):
    tempsta = sorted([[stations[e]['temp'],e] for e in stations])
    minn = [e[1] for e in tempsta][:K]
    return minn
def top_k_max_temp_stations(stations, K):
    tempsta = sorted([[-stations[e]['temp'],e] for e in stations])
    maxx = [e[1] for e in tempsta][:K]
    return maxx
def peak_stations(stations):
    minlat = min([[stations[e]['lat'],e] for e in stations])
    maxlat = max([[stations[e]['lat'],e] for e in stations])
    minlong = min([[stations[e]['long'],e] for e in stations])
    maxlong = max([[stations[e]['long'],e] for e in stations])
    return [minlat[1],maxlat[1],minlong[1],maxlong[1]]
def k_nearby_stations(stations, main_station, K):
    withoutmain = {e:stations[e] for e in stations if e!= main_station}
    nearby = sorted([[distance(stations[main_station]["lat"],stations[main_station]["long"],stations[e]["lat"],stations[e]["long"]),e] for e in withoutmain])
    sta = [e[1] for e in nearby][:K]
    return sta
def average_temp(stations, names):
    tempnames = [stations[e]['temp']for e in stations if e in names]
    return sum(tempnames)/len(tempnames)
# --------------------------------------------------
# 6330239121 (30) 90 (2021-03-26 22:51)

def approx_match(stations, name):
    l = []
    name = name.upper()
    x = ""
    for i in range (len(name)):
        if "A" <= name[i] <= "Z":
            x += name[i]

    for s in stations :
        if x in s:
            l.append(s)
    return l
def top_k_min_temp_stations(stations, K):
    l = []
    for s in stations:
        l.append([stations[s]["temp"],s])
    l.sort()
    l = l[0:K]
    li = []
    for temp,stat in l:
        li.append(stat)
    return li
def top_k_max_temp_stations(stations, K):
    l = []
    for s in stations:
        l.append([-stations[s]["temp"],s])
    l.sort()
    l = l[0:K]
    li = []
    for temp,stat in l:
        li.append(stat)
    return li
def peak_stations(stations):
    l = []
    for s in stations:
        l.append([stations[s]["lat"],s])
    l.sort()
    l = l[0:1]
    li = []
    for lat,stat in l:
        li.append(stat)

    l = []
    for s in stations:
        l.append([-stations[s]["lat"],s])
    l.sort()
    l = l[0:1]
    for lat,stat in l:
        li.append(stat)

    l = []
    for s in stations:
        l.append([stations[s]["long"],s])
    l.sort()
    l = l[0:1]
    for long,stat in l:
        li.append(stat)

    l = []
    for s in stations:
        l.append([-stations[s]["long"],s])
    l.sort()
    l = l[0:1]
    for long,stat in l:
        li.append(stat)

    return li
def k_nearby_stations(stations, main_station, K):
    l = []
    for s in stations:
        l.append([distance(stations[s]["lat"], stations[s]["long"], stations[main_station]["lat"], stations[main_station]["long"]),s])
    l.sort()
    l = l[1:K+1]
    li = []
    for dis,s in l:
        li.append(s)
    return li
def average_temp(stations, names):
    avg = 0
    for s in names:
        avg += stations[s]["temp"]
    avg = avg / len(names)
    return avg
# --------------------------------------------------
# 6330240721 (30) 91 (2021-03-29 21:21)

def approx_match(stations, name):

    names = name.upper().split()
    namex = ''
    for e in names:
        namex += e
    namey = ''.join(name.upper())

    x = []
    for key in stations:
        if name in key.upper():
            x.append(key)
        elif namex in key.upper():
            x.append(key)
        elif namey in key.upper():
            x.append(key)
        elif namex in key.upper().replace(' ',''):
            x.append(key)
        else:
            pass

    return (x)
def top_k_min_temp_stations(stations, K):

    a = []
    NCT = []
    for key in stations:
        a.append(key)
    for e in a:
        NCT.append(stations[e]['temp'])

    zr = []
    for i in range(len(a)):
        zr.append([a[i], NCT[i]])
    zr.sort(key=lambda x: x[0])
    zr.sort(key=lambda x: x[1])

    xx = []
    o = len(zr)
    for i in range(K):
        xx.append(zr[i][0])
        o += -1
        if o == 0:
            break

    return (xx)
def top_k_max_temp_stations(stations, K):

    a = []
    NCT = []
    for key in stations:
        a.append(key)
    for e in a:
        NCT.append(stations[e]['temp'])

    z = []
    for i in range(len(a)):
        z.append([a[i], NCT[i]])
    z.sort(key=lambda x: x[0])
    z.sort(key=lambda x: x[1], reverse=True)

    xx = []
    o = len(z)
    for i in range(K):
        xx.append(z[i][0])
        o += -1
        if o == 0:
            break

    return (xx)
def peak_stations(stations):
    a = []
    NCT = []
    Wanna_One = []

    for key in stations:
        a.append(key)
    for e in a:
        NCT.append(stations[e]['lat'])
    for e in a:
        Wanna_One.append(stations[e]['long'])

    z = []
    for i in range(len(a)):
        z.append([a[i], NCT[i]])
    z.sort(key=lambda x: x[1])

    zz = []
    for i in range(len(a)):
        zz.append([a[i], NCT[i]])
    zz.sort(key=lambda x: x[1], reverse=True)

    zzz = []
    for i in range(len(a)):
        zzz.append([a[i], Wanna_One[i]])
    zzz.sort(key=lambda x: x[1])

    zzzz = []
    for i in range(len(a)):
        zzzz.append([a[i], Wanna_One[i]])
    zzzz.sort(key=lambda x: x[1], reverse=True)

    xx = []
    xx.append(z[0][0])
    xx.append(zz[0][0])
    xx.append(zzz[0][0])
    xx.append(zzzz[0][0])

    return (xx)
def k_nearby_stations(stations, main_station, K):
    a = []
    NCT = []
    Wanna_One = []
    for key in stations:
        a.append(key)
    for e in a:
        NCT.append(stations[e]['lat'])
    for e in a:
        Wanna_One.append(stations[e]['long'])

    N = ''
    c = 0
    for i in range(len(a)):
        if main_station.upper() == a[i].upper():
            N += a[i]
            break
        else:
            c += 1

    z = []
    for i in range(len(a)):
        if i == c:
            pass
        else:
            z.append([a[i], distance(NCT[c], Wanna_One[c], NCT[i], Wanna_One[i])])

    z.sort(key=lambda x: x[1])

    x = []
    o = len(z)
    for i in range(K):
        x.append(z[i][0])
        o += -1
        if o == 0:
            break

    return (x)
def average_temp(stations, names):
    a = []
    NCT = []
    for key in stations:
        a.append(key)
    for e in a:
        NCT.append(stations[e]['temp'])

    y = float(0)
    for i in range(len(a)):
        if a[i] in names:
            y += float(NCT[i])

    z = float(y / len(names))

    return (z)


# --------------------------------------------------
# 6330241321 (29.01) 92 (2021-03-29 20:48)

def approx_match(stations, name):
    r = []
    nameNew = ""
    for a in name :
        if a != " " :
            a = a.upper()
            nameNew += a

    for k in stations :
        kNew = ""
        for a in k :
            if a != " " :
                a.upper()
                kNew += a
        if nameNew in kNew :
           r.append(k)

    return r
def top_k_min_temp_stations(stations, K):
    r = []
    for k in stations :
        if K > len(r) :
            r.append([stations[k]["temp"], k])
            r.sort
        else :
            for i in range (len(r)) :
                if [stations[k]["temp"],k] < r[i] :
                    r.append([stations[k]["temp"], k])
                    r.sort()
                    r = r[:-1]
                    break

    for i in range(len(r)) :
        r[i] = r[i][1]

    return r
def top_k_max_temp_stations(stations, K):
    r = []
    for k in stations :
        if K > len(r) :
            r.append([-stations[k]["temp"], k])
            r.sort
        else :
            for i in range (len(r)) :
                if [-stations[k]["temp"],k] < r[i] :
                    r.append([-stations[k]["temp"], k])
                    r.sort()
                    r = r[:-1]
                    break

    for i in range(len(r)) :
        r[i] = r[i][1]

    return r
def peak_stations(stations):
    r = []
    u = []
    q = []
    for k in stations :
       r.append([stations[k]["lat"], k])
       r.sort()
       s = r[-1]
       t = r[0]
       u.append([stations[k]["long"], k])
       u.sort()
       v = u[-1]
       w = u[0]
    q = [t, s, w ,v]

    for i in range(len(q)) :
        q[i] = q[i][1]


    return q
def k_nearby_stations(stations, main_station, K):
    r = []
    mlat = stations[main_station]["lat"]
    mlong = stations[main_station]["long"]
    for k in stations :
        if k != main_station :
            if K > len(r) :
                a = distance(mlat, mlong, stations[k]["lat"], stations[k]["long"])
                r.append([a, k])
                r.sort()
            else:
                a = distance(mlat, mlong, stations[k]["lat"], stations[k]["long"])
                for i in range(len(r)) :
                    if  r[i] > [a, k] :
                        r.append([a, k])
                        r.sort()
                        r = r[:-1]
                        break

    for i in range(len(r)) :
        r[i] = r[i][1]

    return r
def average_temp(stations, names):
    a = 0
    for n in names :
        a += stations[n]["temp"]
    avg = a / len(names)
    return avg


# --------------------------------------------------
# 6330242021 (28.74) 93 (2021-03-29 19:06)

def approx_match(stations, name):
    name=''.join(name.strip().upper().split())
    o=[]
    for e in stations:
        st=e.upper()
        if name in st:
            o.append(e)
    return o
def top_k_min_temp_stations(stations, K):
    o=[]; p=[]
    for e in stations:
        o.append([stations[e]['temp'],e])
    o.sort()
    o=o[0:K]
    for i,j in o:
        p.append(j)
    return p
def top_k_max_temp_stations(stations, K):
    o=[]; p=[]
    for e in stations:
        o.append([stations[e]['temp'],e])
    o=sorted(o,reverse=True)
    o=o[0:K]
    for i,j in o:
        p.append(j)
    return p
def peak_stations(stations):
    o=[]; p=[] ; q=[]
    for e in stations:
        o.append([stations[e]['lat'],e])
    for e in stations:
        p.append([stations[e]['long'],e])
    o.sort(); p.sort()
    q+=o[0][1].split(',')+o[-1][1].split(',')+p[0][1].split(',')+p[-1][1].split(',')
    return q
def k_nearby_stations(stations, main_station, K):
    o=[]; q=[]
    x1=stations[main_station]['lat']
    y1=stations[main_station]['long']
    for i,j in stations.items():
        x2=j['lat']
        y2=j['long']
        if x1!=x2 and y1!=y2:
            o.append([distance(x1,y1,x2,y2),i])
    o.sort()
    o=o[0:K]
    for i,j in o:
        q.append(j)
    return q
def average_temp(stations, names):
    o=0
    for e in names:
        o+=stations[e]['temp']
    n=len(names); O=round(o/n,1)
    return O
# --------------------------------------------------
# 6330243621 (30) 94 (2021-03-27 15:04)

def approx_match(stations, name):
    s = []
    n = ''
    N = name.upper()
    if not N in stations :
        for i in N :
            if not ('A' <= i <= 'Z' or i == ' '):
                n = []
                break
            elif 'A' <= i <= 'Z' :
                n += i
            else : n += ''
        for i in stations :
            if n != [] and n in i:
                s.append(i)
        return s
    else : return [N]
def top_k_min_temp_stations(stations, K):
    st = []
    sr = []
    for i in stations :
        st.append([stations[i]['temp'],i])
    st.sort()
    if st != [] and K >= 0 :
        for i in st :
            sr.append(i[-1])
        sr = sr[:K]
        return sr
    return []
def top_k_max_temp_stations(stations, K):
    st = []
    sr = []
    for i in stations :
        st.append([stations[i]['temp'],i])
    st.sort(key=lambda sl:(-sl[0],sl[1]))
    if st != [] and K >= 0 :
        for i in st :
            sr.append(i[-1])
        sr = sr[:K]
        return sr
    return []
def peak_stations(stations):
    lat,long = [],[]
    for i in stations :
        lat.append([stations[i]['lat'],i])
        long.append([stations[i]['long'],i])
    lat.sort()
    long.sort()
    if lat != [] and long != [] :
        return [lat[0][-1],lat[-1][-1],long[0][-1],long[-1][-1]]
    return []
def k_nearby_stations(stations, main_station, K):
    st = []
    sr = []
    for i in stations :
        if i != main_station :
            st.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i])
    st.sort()
    if st != [] and K >= 0:
        for i in st :
            sr.append(i[-1])
        return sr[:K]
    return sr
def average_temp(stations, names):
    tp = 0
    for i in names :
        tp += stations[i]['temp']
    if len(names) != 0 :
        return round(tp/len(names), 1)
    else : return 0

# --------------------------------------------------
# 6330245921 (30) 95 (2021-03-29 11:21)

def approx_match(stations, name):
    v = ''
    for i in name.upper():
        v += i.strip()
    z = []
    x = ''
    for e in stations:
        for c in e:
            x+=c.strip().upper()
        if v in x:
            z += [e]
        x = ''
    return z
def top_k_min_temp_stations(stations, K):
    z = []
    for i in stations:
        z += [[stations[i]['temp'],i]]
    x = []
    for i in sorted(z)[0:K]:
        x += [i[1]]
    return x
def top_k_max_temp_stations(stations, K):
    z = []
    for i in stations:
        z += [[-stations[i]['temp'],i]]
    x = []
    for i in sorted(z)[0:K]:
        x += [i[1]]
    return x
def peak_stations(stations):
    v = []
    for i in stations:
        v += [[stations[i]['lat'],i]]
    c = []
    for i in sorted(v):
        c += [i[1]]
    b = c[0]
    z = c[-1]
    f = []
    for i in stations:
        f += [[stations[i]['long'],i]]
    j= []
    for i in sorted(f):
        j += [i[1]]
    k = j[0]
    l = j[-1]
    return [b,z,k,l]
def k_nearby_stations(stations, main_station, K):
    Lat1 = stations[main_station]['lat']
    Long1= stations[main_station]['long']
    n = []
    for i in stations:
        n += [[distance(Lat1,Long1,stations[i]['lat'],stations[i]['long']),i]]
    b = []
    for i in sorted(n):
        b += [i[1]]
    return b[1:K+1]
def average_temp(stations, names):
    b = 0
    for i in names:
        b += stations[i]['temp']
    return (b/len(names))
# --------------------------------------------------
# 6330246521 (30) 96 (2021-03-29 00:48)

def approx_match(stations, name):
    x = name.upper()
    x = x.split()
    new_name = ''.join(x)
    list_of_stations = []
    for n in stations:
        y = n.upper()
        new_stations = y.split()
        new_stations = ''.join(new_stations)
        if new_name in new_stations:
            list_of_stations.append(n)
    return list_of_stations
def top_k_min_temp_stations(stations, K):
    min_temp = []
    for e in stations:
        min_temp.append([stations[e]['temp'], e])
    min_temp.sort()
    stations_name = []
    for n in min_temp[:K]:
        stations_name.append(n[1])
    return stations_name
def top_k_max_temp_stations(stations, K):
    x = []
    for e in stations:
        x.append([stations[e]['temp']*-1, e])
    x.sort()
    max_temp = []
    for e in x:
        max_temp.append([e[0]*-1, e[1]])
    stations_name = []
    for n in max_temp[:K]:
        stations_name.append(n[1])
    return stations_name
def peak_stations(stations):
    lat  = []
    long = []
    for e in stations:
        lat.append( [stations[e]['lat'] , e])
        long.append([stations[e]['long'], e])
    lat.sort()
    long.sort()
    stations_name = []
    stations_name.append(lat[ 0][1])
    stations_name.append(lat[-1][1])
    stations_name.append(long[ 0][1])
    stations_name.append(long[-1][1])
    return stations_name
def k_nearby_stations(stations, main_station, K):
    lat1  = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    stations_distance = []
    for n in stations:
        lat2  = stations[n]['lat']
        long2 = stations[n]['long']
        d = distance(lat1, long1, lat2, long2)
        stations_distance.append([d, n])
    stations_distance.sort()
    stations_name = []
    for e in stations_distance[1:K+1]:
        stations_name.append(e[1])
    return stations_name
def average_temp(stations, names):
    temp = []
    for n in names:
        t = stations[n]['temp']
        temp.append(t)
    return sum(temp)/len(temp)
# --------------------------------------------------
# 6330247121 (28.74) 97 (2021-03-29 23:05)

def approx_match(stations, name):
    x = []
    y= ''
    for e in name:
        if e!=" ":
            y+=e
    for e in stations:
        ee = ""
        for i in e :
            if i!=" ":
                ee+=i

        if y.upper() in ee.upper():
            x.append(e)
    return x
def top_k_min_temp_stations(stations, K):
    x = []
    for e in stations:
        y = []
        y.append(stations[e]['temp'])
        y.append(e)
        x.append(y)
    x.sort()
    b = x[0:K]
    c = []
    for i in range(len(b)):
        a = b[i]
        a1 = a[1]
        c.append(a1)
    return c
def top_k_max_temp_stations(stations, K):
    x = []
    for e in stations:
        y = []
        y.append(stations[e]['temp'])
        y.append(e)
        x.append(y)
    x.sort()
    b = x[::-1]
    b = b[:K]
    h = []
    for i in range(len(b)):
        f = b[i]
        f1 = f[1]
        h.append(f1)
    return h
def peak_stations(stations):
    lats =[]
    longs = []
    for e in stations:
        lat  = stations[e]['lat' ]
        x = [lat,e]
        lats.append(x)
        long = stations[e]['long']
        y = [long,e]
        longs.append(y)
    latmax=(sorted(lats,reverse=True))[0]
    latmin=(sorted(lats))[0]
    longmax =(sorted(longs,reverse=True))[0]
    longmin =(sorted(longs))[0]
    peak =[latmin[1],latmax[1],longmin[1],longmax[1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    x =[]
    y =[]
    latm = stations[main_station]['lat' ]
    longm = stations[main_station]['long']
    for e in stations:
        lat  = stations[e]['lat' ]
        long = stations[e]['long']
        a = distance(latm, longm, lat, long)
        b = [a,e]
        x.append(b)
    d =sorted(x)
    for i in range(len(d)):
        e = d[i]
        f = e[1]
        y.append(f)
    g = y[1:K+1]
    return g
def average_temp(stations, names):
    total = 0
    for i in range(len(names)):
        x =names[i]
        y = stations[x]['temp']
        total +=y
    return total / len(names)

# --------------------------------------------------
# 6330248821 (26) 98 (2021-03-29 23:47)

def approx_match(stations, name):

    name = name.replace(" ","").lower()
    names = []
    for station, value in stations.items():
        if name in station.lower().replace(' ',''):
            names.append(station)

    return names
def top_k_min_temp_stations(stations, K):

    temp = []
    name = []
    for k in (stations):
        temp.append([stations[k]['temp'],k])
    temp.sort()
    for i in range(len(temp)):
        name.append(temp[i][1])
    if K > len(name):
        return name
    else :
        return name[:K]
def top_k_max_temp_stations(stations, K):

    temp = []
    name = []
    for k in (stations):
        temp.append([-stations[k]['temp'],k])
    temp.sort()
    for i in range(len(temp)):
        name.append(temp[i][1])
    if K > len(name):
        return name
    else :
        return name[:K]
def peak_stations(stations):

    name = []
    lat_list = sorted(list([station[e]['lat'],e] for e in stations))
    long_list = sorted(list([station[e]['long'],e] for e in stations))
    name.append(lat_list[0][1])
    name.append(lat_list[len(lat_list)-1][1])
    name.append(long_list[0][1])
    name.append(long_list[len(long_list)-1][1])
    return name
def k_nearby_stations(stations, main_station, K):
    mainLat = stations[main_station]['lat']
    mainLong = stations[main_station]['long']
    dis = []
    for e in stations:
        if e != main_station:
            dis.append([distance(mainLat,mainLong,stations[e]['lat'],stations[e]['long']),e])
    dis.sort()
    name = list(dis[i][1] for i in range(len(dis)))
    if K > len(name):
        return name
    else :
        return name[:K]
def average_temp(stations, names):
    temp = 0.0
    c=0
    for e in names :
        if e in stations :
            c+=1
            temp += stations[e]['temp']
    avg = temp/c
    return avg


# --------------------------------------------------
# 6330249421 (30) 99 (2021-03-28 14:44)

def approx_match(stations, name):
    name=name.upper()
    w=''
    ans=[]
    for i in range(len(name)):
        if ' '==name[i]:
            w+=''
        else :
            w+=name[i]
    for e in stations :
        s=''
        for ch in e:
            if ' '==ch:
                s+=''
            else :
                s+=ch
        if w in s.upper() :
            ans.append(e)
    return ans
def top_k_min_temp_stations(stations, K):
    s=[]
    ans=[]
    for e in stations:
        s.append([stations[e]['temp'],e])
    s.sort()
    for i in range(K):
        ans.append((s[i])[1])
    return ans
def top_k_max_temp_stations(stations, K):
    s=[]
    ans=[]
    for e in stations:
        s.append([-stations[e]['temp'],e])
    s.sort()
    for i in range(K):
        ans.append((s[i])[1])
    return ans
def peak_stations(stations):
    latitude=[]
    longtitude=[]
    s_lat={}
    s_long={}
    for e in stations:
        latitude.append(stations[e]['lat'])
        longtitude.append(stations[e]['long'])
        s_lat[stations[e]['lat']]=e
        s_long[stations[e]['long']]=e
    latitude_max=s_lat[max(latitude)]
    latitude_min=s_lat[min(latitude)]
    longtitude_max=s_long[max(longtitude)]
    longtitude_min=s_long[min(longtitude)]
    return [latitude_min,latitude_max,longtitude_min,longtitude_max]
def k_nearby_stations(stations, main_station, K):
    ans=[]
    lat2=stations[main_station]['lat']
    long2=stations[main_station]['long']
    for e in stations:
        if e!=main_station :
            ans.append([distance(stations[e]['lat'],stations[e]['long'],lat2,long2),e])
    ans.sort()
    ans=ans[:K:]
    anss=[]
    for i in range(len(ans)):
        anss.append((ans[i])[1])
    return anss
def average_temp(stations, names):
    s=[]
    for i in range(len(names)):
        s.append(stations[names[i]]['temp'])
    ans=sum(s)/len(s)
    return ans



# --------------------------------------------------
# 6330250021 (30) 100 (2021-03-28 20:58)

def approx_match(stations, name):
    n=''
    s=[]
    for a in name:
        if a!=' ':
            n+=a
    for k in stations:
        b=''
        for a in k:
            if a!=' ':
                b+=a
        if n.lower() in b.lower():
            s.append(k)
    return s
def top_k_min_temp_stations(stations, K):
    s=[]
    for k in stations:
        s.append([stations[k]['temp'],k])
    s.sort()
    top=[]
    for a,b in s:
        top.append(b)
    return top[:K]
def top_k_max_temp_stations(stations, K):
    s=[]
    for k in stations:
        s.append([(-1)*stations[k]['temp'],k])
    s.sort()
    top=[]
    for a,b in s:
        top.append(b)
    return top[:K]
def peak_stations(stations):
    lat=[]
    for k in stations:
        lat.append([stations[k]['lat'],k])
    lat.sort()
    long=[]
    for k in stations:
        long.append([stations[k]['long'],k])
    long.sort()
    return([lat[0][1],lat[-1][1],long[0][1],long[-1][1]])
def k_nearby_stations(stations, main_station, K):
    d=[]
    lat=stations[main_station]['lat']
    long=stations[main_station]['long']
    for k in stations:
        if k!=main_station:
            d.append([distance(lat,long,stations[k]['lat'],stations[k]['long']),k])
    d.sort()
    near=[]
    for a,b in d:
        near.append(b)
    return near[:K]
def average_temp(stations, names):
    t=0
    for k in stations:
        if k in names:
            t+=stations[k]['temp']
    return t/len(names)

# --------------------------------------------------
# 6330251621 (30) 101 (2021-03-28 10:49)

def approx_match(stations, name):
    name_real = ''
    for a in name:
        if a != ' ':
            name_real += a.upper()
    stations_real = []
    for i in stations:
        if name_real in i.upper():
            stations_real.append(i)
    return stations_real
def top_k_min_temp_stations(stations, K):
    temp_min = []
    for a in stations:
        temp_min.append([stations[a]['temp'],a])
    temp_min.sort()
    temp_min_K = []
    for e in range(K):
        temp_min_K.append(temp_min[e][1])
    return temp_min_K
def top_k_max_temp_stations(stations, K):
    temp_max = []
    for a in stations:
        temp_max.append([stations[a]['temp']*(-1),a])
    temp_max.sort()
    temp_max_K = []
    for e in range(K):
        temp_max_K.append(temp_max[e][1])
    return temp_max_K
def peak_stations(stations):
    lati = []
    for la in stations:
        lati.append([stations[la]['lat'],la])
    lati.sort()
    long = []
    for lo in stations:
        long.append([stations[lo]['long'],lo])
    long.sort()
    peak = [lati[0][1],lati[-1][1],long[0][1],long[-1][1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    dis_all = []
    for i in stations:
        dis = distance(stations[main_station]['lat'] , \
                       stations[main_station]['long'] , \
                       stations[i]['lat'] , \
                       stations[i]['long']  )
        dis_all.append([dis,i])
    dis_all.sort()
    dis_all_K = []
    for i in range(1,K+1):
        if i < len(dis_all):
            dis_all_K.append(dis_all[i][1])
    return dis_all_K
def average_temp(stations, names):
    avg = []
    for a in names:
        avg.append(stations[a]['temp'])
    avg = sum(avg)/len(avg)
    return avg



# --------------------------------------------------
# 6330252221 (28.74) 102 (2021-03-29 11:23)

def approx_match(stations, name):
    a=[]
    b=''
    name=name.lower()
    for e in name:
        if e!=' ':
            b+=e
    for e in stations:
        if b.upper() in e.upper():
            a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    for e in stations:
        b=[]
        b.append(stations[e]['temp'])
        b.append(e)
        a.append(b)
    a.sort()
    c=[]
    for e in a:
        c.append(e[1])
    c=c[:K]
    return c
def top_k_max_temp_stations(stations, K):
    a=[]
    for e in stations:
        b=[]
        b.append(stations[e]['temp'])
        b.append(e)
        a.append(b)
    a.sort()
    c=[]
    for e in a:
        c.append(e[1])
    c=c[::-1]
    c=c[:K]
    return c
def peak_stations(stations):
    peakall=[]
    lat=[]
    long=[]
    for e in stations:
        lat.append([stations[e]['lat'],e])
    lat.sort()
    for e in stations:
        long.append([stations[e]['long'],e])
    long.sort()
    peakall.append(lat[0][1])
    peakall.append(lat[-1][1])
    peakall.append(long[0][1])
    peakall.append(long[-1][1])
    return peakall
def k_nearby_stations(stations, main_station, K):
    a=stations[main_station]['lat']
    b=stations[main_station]['long']
    c=[]
    for e in stations:
        d=stations[e]['lat']
        f=stations[e]['long']
        distan=distance(a, b, d, f)
        c.append([distan,e])
    c.sort()
    last=[]
    for e in c:
        last.append(e[1])
    last=last[1:K+1]
    return last
def average_temp(stations, names):
    a=0
    n=0
    for e in names:
        a+=stations[e]['temp']
        n+=1
    b=a/n
    return b


# --------------------------------------------------
# 6330253921 (30) 103 (2021-03-29 21:17)

def approx_match(stations, name):
    t = cutspace(name)
    f = []
    for i in stations:
        e = cutspace(i)
        if t.upper() in e.upper():
            f.append(i)
    return f
def top_k_min_temp_stations(stations, K):
    f = []
    for i in stations:
        f.append([stations[i]['temp'],i])
    f.sort()
    x = sortmin(f)
    y = []
    for i in range(K):
        y.append(x[i])
    return y
def top_k_max_temp_stations(stations, K):
    f = []
    for i in stations:
        f.append([stations[i]['temp'],i])
    f.sort()
    x = sortmax(f)
    l = []
    for i in range(K):
        l.append(x[i])
    return l
def peak_stations(stations):
    la = []
    for i in stations:
        la.append([stations[i]['lat'],i])
    la.sort()
    lo = []
    for i in stations:
        lo.append([stations[i]['long'],i])
    lo.sort()
    lamax = la[-1]
    lamin = la[0]
    lomax = lo[-1]
    lomin = lo[0]
    al = []
    al.append(lamin[1])
    al.append(lamax[1])
    al.append(lomin[1])
    al.append(lomax[1])
    return al
def k_nearby_stations(stations, main_station, K):
    f = []
    ll = []
    for i in stations:
        if main_station.upper() != i.upper():
            f.append([stations[i]['lat'],stations[i]['long']])
            ll.append(i)
    l = []
    for i in range(len(f)):
        l.append([distance(stations[main_station.upper()]['lat'],stations[main_station.upper()]['long'],f[i][0],f[i][1]),ll[i]])
    l.sort()
    r = sortmin(l)
    o = []
    for i in range(K):
        o.append(r[i])
    return o
def average_temp(stations, names):
    f = []
    for i in names:
        f.append(stations[i]['temp'])
    c = 0
    for i in f:
        c += i
    return c/len(f)
# --------------------------------------------------
def cutspace(a):
    c = a.split()
    t = ''
    for i in c:
        t += i
    return t
def sortmin(o):
    y = []
    z = []
    for j in o:
        if j[0] in y:
            k = y.index(j[0])
            z[k].append(j[1])
        else:
            y.append(j[0])
            z.append([j[1]])
    x = []
    for k in z:
        if len(k) != 1:
            k.sort()
            for i in k:
                x.append(i)
        else:
            for i in k:
                x.append(i)
    return x
def sortmax(o):
    y = []
    z = []
    for j in o:
        if j[0] in y:
            k = y.index(j[0])
            z[k].append(j[1])
        else:
            y.append(j[0])
            z.append([j[1]])
    y1 = []
    z1 = []
    for i in range(len(y)):
        y1.append(y[-i-1])
        z1.append(z[-i-1])
    x = []
    for k in z1:
        if len(k) != 1:
            k.sort()
            for i in k:
                x.append(i)
        else:
            for i in k:
                x.append(i)
    return x
# 6330254521 (30) 104 (2021-03-29 05:42)

def approx_match(stations, name):
    name = name.strip().upper()
    names=''
    for e in name:
        if "A" <= e <= "Z":
            names+=e
    samename_list =[namie for namie in stations if names in namie]
    return samename_list
def top_k_min_temp_stations(stations, K):
    temp_list=[[stations[name]['temp'],name] for name in stations]
    temp_list.sort()
    listt =[ e[1] for e in temp_list]
    return listt[:K]
def top_k_max_temp_stations(stations, K):
    temp_list=[[-(stations[name]['temp']),name] for name in stations]
    temp_list.sort()
    listt =[ e[1] for e in temp_list]
    return listt[:K]
def peak_stations(stations):
    lat=[[stations[name]['lat'],name] for name in stations]
    long=[[stations[name]['long'],name] for name in stations]
    lat.sort()
    long.sort()
    return [lat[0][1],lat[len(lat)-1][1],long[0][1],long[len(lat)-1][1]]
def k_nearby_stations(stations, main_station, K):
    long_main = stations[main_station]['long']
    lat_main = stations[main_station]['lat']
    lat_long=[[stations[name]['long'],stations[name]['lat'],name] for name in stations]
    distance_list=[[distance(lat_long[i][1],lat_long[i][0],lat_main,long_main),lat_long[i][2]] for i in range(len(lat_long))]
    distance_list.sort()
    name_list=[ e[1] for e in distance_list ]
    name_list.remove(main_station)
    return name_list[:K]
def average_temp(stations, names):
   average_temp=0
   for city in names:
       average_temp += stations[city]['temp']
   return average_temp/len(names)
# --------------------------------------------------
# 6330255121 (22.5) 105 (2021-03-29 23:56)

def approx_match(stations, name):
    l = []
    changed_name = ''
    for w in name:
        if w !=' ':
            changed_name += w.upper()

    for n in stations:
        new_n = ''
        for w in n:
            if w != ' ':
                new_n += w.upper()
        if changed_name in new_n:
            l.append(n)

    return l
# --------------------------------------------------
def top_k_min_temp_stations(stations, K):
    listoftemp = []
    for n in stations:
        if len(listoftemp) < K:
            listoftemp.append([stations[n]['temp'],n])
            listoftemp.sort()
        else:
            listoftemp[:K]

    for i in range(len(listoftemp)):
        n[i] = n[i][1]

    return r

# --------------------------------------------------
def top_k_max_temp_stations(stations, K):
    listoftemp = []
    for n in stations:
        if len(listoftemp) < K:
            listoftemp.append([stations[n]['temp'],n])
            listoftemp.sort()
            listoftemp[::-1]
        else:
            listoftemp.sort[:K]

    for n in range(len(listoftemp)):
        n[i] = n[i][1]


# --------------------------------------------------
def peak_stations(stations):
    ll_list = []
    for k in stations:
        if len(ll_list)==0 :
            ll_list = [[stations[k]['lat'], k], [stations[k]['lat'], k], [stations[k]['long'], k], [stations[k]['long'], k]]

        else:
            if [stations[k]['lat'], k] < ll_list[0]:
                ll_list[0] = [stations[k]['lat'], k]

            if [stations[k]['lat'], k] > ll_list[1]:
                ll_list[1] = [stations[k]['lat'], k]

            if [stations[k]['lat'], k] < ll_list[2]:
                ll_list[2] = [stations[k]['long'], k]

            if [stations[k]['lat'], k] > ll_list[3]:
                ll_list[3] = [stations[k]['long'], k]

    for i in range(len(ll_list)):
        ll_list[i]=ll_list[i][1]

    return ll_list

# --------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    d_list = []
    for k in stations:
        if k != main_station:
            if len(d_list) < K:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                d_list.append([d, k])
                d_list.sort()
            else:
                d_list[:K-1]
    for n in range(len(d_list)):
        d_list[n] = d_list[n][1]

    return d_list


# --------------------------------------------------
def average_temp(stations, names):
    v=0
    for k in names:
        if len(names) != 0:
            v += stations[k]['temp']
    r = v/len(names)

    return r

# --------------------------------------------------
# 6330257421 (30) 106 (2021-03-27 21:53)

def approx_match(stations, name):
    b=''
    c=[]
    for i in name:
        a=i.upper()
        if a!= ' ':
            b=b+a
    for i in stations:
        j=i.upper()
        if b in j:
            c.append(i)
    return c
def top_k_min_temp_stations(stations, K):
    j=[]
    z=[]
    for i in stations:
        j.append([stations[i]['temp'],i])
    j.sort()
    j=j[:K]
    for i in range(len(j)):
        z.append(j[i][1])
    return z
def top_k_max_temp_stations(stations, K):
    j=[]
    z=[]
    for i in stations:
        j.append([stations[i]['temp']*-1,i])
    j.sort()
    j=j[:K]
    for i in range(len(j)):
        j[i][0]=j[i][0]*-1
        z.append(j[i][1])
    return z
def peak_stations(stations):
    j=[]
    z=[]
    for i in stations:
        j.append([stations[i]['lat'],i])
    j.sort()
    z.append(j[0][1])
    z.append(j[-1][1])
    j=[]
    for i in stations:
        j.append([stations[i]['long'],i])
    j.sort()
    z.append(j[0][1])
    z.append(j[-1][1])
    return z
def k_nearby_stations(stations, main_station, K):
    j=[]
    z=[]
    for i in stations:
        dis=distance(stations[i]['lat'], stations[i]['long'], stations[main_station]['lat'], stations[main_station]['long'])
        if(dis!=0):
            j.append([dis,i])
    j.sort()
    j=j[:K]
    for i in range(len(j)):
        z.append(j[i][1])
    return z
def average_temp(stations, names):
    sum=0
    n=0
    for i in names:
        sum=sum+stations[i]['temp']
        n=n+1
    sum=sum/n
    return sum


# --------------------------------------------------
# 6330258021 (30) 107 (2021-03-25 11:28)

def approx_match(stations, name):
    l = []
    for i in stations :
        if reformat(name) in reformat(i) : l.append(i)
    return l
def top_k_min_temp_stations(stations, K):
    l,out = [],[]
    for i in stations : l.append([stations[i]['temp'],i])
    for i in sorted(l)[:K] : out.append(i[1])
    return out
def top_k_max_temp_stations(stations, K):
    l,out = [],[]
    for i in stations : l.append([-stations[i]['temp'],i])
    for i in sorted(l)[:K] : out.append(i[1])
    return out
def peak_stations(stations):
    lat,lon = [],[]
    for i in stations :
        lat.append([stations[i]['lat'],i])
        lon.append([stations[i]['long'],i])
    return [min(lat)[1],max(lat)[1],min(lon)[1],max(lon)[1]]
def k_nearby_stations(stations, main_station, K):
    dfm,out = [],[]
    for i in stations : dfm.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i])
    for i in sorted(dfm)[1:K+1] : out.append(i[1])
    return out
def average_temp(stations, names):
    temp = []
    for i in names : temp.append(stations[i]['temp'])
    return sum(temp)/len(temp)

# --------------------------------------------------
def reformat(s) : return s.lower().replace(' ','')
# 6330259721 (29.6) 108 (2021-03-27 23:01)

def approx_match(stations, name):

    x = []
    name=name.upper()
    r = ""
    for e in name:
        if e == " ":
            pass
        else:
            r += e
    for f in stations :
        i = f.upper()
        if r in i :
            x.append(f)
    return(x)
def top_k_min_temp_stations(stations, K):

    x = []
    y = []
    for f in dict_of_temperature(stations):
        x.append([dict_of_temperature(stations)[f],f])
    x.sort()
    if K <= len(x):
        for i in range(K):
            y.append(x[i][1])
    else:
        K = len(x)
        for i in range(K):
            y.append(x[i][1])

    return(y)
def top_k_max_temp_stations(stations, K):

    x = []
    y = []
    for f in dict_of_temperature(stations):
        x.append([dict_of_temperature(stations)[f]*-1,f])
    x.sort()
    if K <= len(x):
        for i in range(K):
            y.append(x[i][1])
    else:
        K = len(x)
        for i in range(K):
            y.append(x[i][1])

    return(y)
def peak_stations(stations):

    x = []
    for f in dict_of_lat(stations):
        x.append([dict_of_lat(stations)[f],f])
    x.sort()
    min_lat = x[0][1]
    max_lat = x[-1][1]
    y = []
    for f in dict_of_long(stations):
        y.append([dict_of_long(stations)[f],f])
    y.sort()
    min_long = y[0][1]
    max_long = y[-1][1]

    return(min_lat,max_lat,min_long,max_long)
def k_nearby_stations(stations, main_station, K):

    gps = []
    gps.append(stations[main_station]["lat"])
    gps.append(stations[main_station]["long"])
    x = []
    for e in stations:
        x.append([distance(gps[0], gps[1],stations[e]["lat"],stations[e]["long"]),e])
    x.sort()
    x = x[1:]
    y = []
    for i in range(K):
        y.append(x[i][1])

    return(y)
def average_temp(stations, names):

    x = []
    y = []
    for f in names :
        x.append(dict_of_temperature(stations)[f])
    for i in x:
        y.append(float(i))
    av_temp = sum(y)/len(y)

    return(av_temp)


# --------------------------------------------------
def dict_of_temperature(stations):
    d = {}
    for e in stations :
        d[e] = stations[e]["temp"]
    return(d)
def dict_of_lat(stations):
    d = {}
    for e in stations :
        d[e] = stations[e]["lat"]
    return(d)
def dict_of_long(stations):
    d = {}
    for e in stations :
        d[e] = stations[e]["long"]
    return(d)
# 6330260221 (28.74) 109 (2021-03-29 14:00)

def approx_match(stations, name):
    Nname = []
    for i in stations.keys():
        if ''.join(name.split()).upper() in i:
            Nname.append(i)

    return Nname
def top_k_min_temp_stations(stations, K):
    Nname = []
    N2name = []
    for i in stations.keys():
        Nname.append([stations[i]['temp'],i])
    Nname.sort()
    Nname = Nname[0:K]
    for j in Nname:
        N2name.append(j[1])
    return N2name
def top_k_max_temp_stations(stations, K):
    Nname = []
    N2name = []
    for i in stations.keys():
        Nname.append([stations[i]['temp'],i])
    Nname.sort(reverse=True)
    Nname = Nname[:K]
    for j in Nname:
        N2name.append(j[1])
    return N2name
def peak_stations(stations):
    Ltitude = []
    Lotitude = []
    for i in stations.keys():
        Ltitude.append([stations[i]['lat'],i])
        Lotitude.append([stations[i]['long'],i])
    Atitude = [min(Ltitude)[1],max(Ltitude)[1],min(Lotitude)[1],max(Lotitude)[1]]
    return Atitude
def k_nearby_stations(stations, main_station, K):
    Nstations = []
    Nstations2 = []
    a = stations[main_station]['lat']
    b = stations[main_station]['long']
    for i in stations.keys():
        if i != main_station.upper():
            Nstations.append([distance(a,b,stations[i]['lat'],stations[i]['long']),i])
    Nstations.sort()
    for j in Nstations[:K]:
        Nstations2.append(j[1])
    return Nstations2
def average_temp(stations, names):
    avg = 0
    n = 0
    for i in names:
        avg += stations[i]['temp']
        n+=1
    avg = avg/n
    return avg



# --------------------------------------------------
# 6330261921 (30) 110 (2021-03-29 14:06)

def approx_match(stations, name):
    sta=[]
    nam=''.join(name.split()).upper()
    for i in stations:
        if nam in ''.join(i.split()).upper():sta.append(i)
    return sta
def top_k_min_temp_stations(stations, K):
    sta=[]
    for i in stations:
        sta.append([stations[i]['temp'],i])
    sta.sort()
    sta=sta[0:K]
    sta=[i[1] for i in sta]
    return sta
def top_k_max_temp_stations(stations, K):
    sta=[]
    for i in stations:
        sta.append([-( stations[i]['temp'] ),i])
    sta.sort()
    sta=sta[0:K]
    sta=[i[1] for i in sta]
    return sta
def peak_stations(stations):
    la=[]
    lo=[]
    for i in stations:
        la.append([stations[i]['lat'],i])
        lo.append([stations[i]['long'],i])
    la.sort()
    lo.sort()
    mila,mala=la[0][1],la[-1][1]
    milo,malo=lo[0][1],lo[-1][1]
    return [mila,mala,milo,malo]
def k_nearby_stations(stations, main_station, K):
    latmain=stations[main_station]['lat']
    longmain=stations[main_station]['long']
    close=[]
    for i in stations:
        close.append([distance(latmain,longmain,stations[i]['lat'],stations[i]['long']),i])
    close.sort()
    close=close[1:K+1]
    close=[i[1] for i in close]
    return close
def average_temp(stations, names):
    sum=0
    if len (names)==0:return 0
    for i in names:
        sum+= stations[i]['temp']
    return sum/len(names)

# --------------------------------------------------
# 6330262521 (30) 111 (2021-03-28 14:04)

def approx_match(stations, name):
    aaa = []
    k = list(stations.keys())
    name = name.upper()
    n = ''
    for i in name:
        if i != ' ':
            n += i
    for i in k:
        ii = ''
        for a in i:
            if a != ' ':
                ii += a
        if n in ii.upper():
            aaa.append(i)
    return aaa
def top_k_min_temp_stations(stations, K):
    a = []
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort()
    t = []
    if len(a) > K:
        for i in range(K):
            t.append(a[i][1])
    else:
        K = len(a)
        for i in range(K):
            t.append(a[i][1])
    return t
def top_k_max_temp_stations(stations, K):
    a = []
    for i in stations:
        a.append([stations[i]['temp'],i])
    for i in range(len(a)):
        a[i][0] *= -1
    a.sort()
    for i in range(len(a)):
        a[i][0] *= -1
    t = []
    if len(a) > K:
        for i in range(K):
            t.append(a[i][1])
    else:
        K = len(a)
        for i in range(K):
            t.append(a[i][1])
    return t
def peak_stations(stations):
    lat = []
    for i in stations:
        lat.append([[stations[i]['lat']],i])
    long = []
    for i in stations:
        long.append([[stations[i]['long']],i])
    lat.sort()
    long.sort()
    a = []
    a.append(lat[0][1])
    a.append(lat[-1][1])
    a.append(long[0][1])
    a.append(long[-1][1])
    return a
def k_nearby_stations(stations, main_station, K):
    a1 = {}
    a1[main_station] = [stations[main_station]['lat'],stations[main_station]['long']]
    a2 = {}
    for i in stations:
        if i != main_station:
            a2[i] = [stations[i]['lat'],stations[i]['long']]
    a = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for i in a2:
        d = distance(lat1, long1, stations[i]['lat'], stations[i]['long'])
        a.append([d,i])
    a.sort()
    aa = []
    if len(a) > K:
        for i in range(K):
            aa.append(a[i][1])
    else:
        K = len(a)
        for i in range(K):
            aa.append(a[i][1])
    return aa
def average_temp(stations, names):
    c = 0
    l = len(names)
    for i in stations:
        if i in names:
            c+=stations[i]['temp']
    return c/l

# --------------------------------------------------
# 6330263121 (25.98) 112 (2021-03-29 21:26)

def approx_match(stations, name):
    name1 =name.split()
    name2 =''.join(name1)
    name3 = name2.upper()
    c =[]
    stations1 = show_all_station_names1(stations)
    for i in range(len(stations1)):
        a = stations1[i].upper()
        b = ''
        for j in range(len(a)):
            if a[j] in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
                b += a[j]
            else:
                b +=''
        for k in range(len(b)):
            if b[k:len(name)+k]==name3:
                c.append(a)
    return c
def top_k_min_temp_stations(stations, K):
    stations1 = tempmin(stations)
    stations2 = sorted(stations1)
    b = stations2[0:K]
    c = []
    for i in range(len(b)):
        a = b[i]
        a1 = a[1]
        c.append(a1)
    return c
def top_k_max_temp_stations(stations, K):
    stations1 = tempmax(stations)
    stations2 = sorted(stations1)
    b = stations2[0:K]
    c = []
    for i in range(len(b)):
        a = b[i]
        a1 = a[1]
        c.append(a1)
    return c
def peak_stations(stations):
    stations1 = show_all_station_names1(stations)
    lats =[]
    longs = []
    for i in range(len(stations1)):
        name = stations1[i].upper()
        lat  = stations[name]['lat' ]
        long = stations[name]['long']
        a = [lat,name]
        b = [long,name]
        lats.append(a)
        longs.append(b)
    amax=(sorted(lats,reverse=True))[0]
    amax1=amax[1]
    amin=(sorted(lats))[0]
    amin1=amin[1]
    bmax =(sorted(longs,reverse=True))[0]
    bmax1 = bmax[1]
    bmin =(sorted(longs))[0]
    bmin1 = bmin[1]
    peak =[amin1,amax1,bmin1,bmax1]
    return peak
def k_nearby_stations(stations, main_station, K):
    latmain  = stations[main_station]['lat' ]
    longmain = stations[main_station]['long']
    stations1 = show_all_station_names1(stations)
    p =[]
    m =[]
    for i in range(len(stations1)):
        name = stations1[i].upper()
        lat  = stations[name]['lat' ]
        long = stations[name]['long']
        a = distance(latmain, longmain, lat, long)
        b = [a,name]
        p.append(b)
    p1 =sorted(p)
    for j in range(len(p1)):
        p2 = p1[j]
        p3 = p2[1].upper()
        m.append(p3)
    p4 = m[1:K+1]
    return p4
def average_temp(stations, names):
    b=0
    for i in range(len(names)):
        a =names[i]
        a1 = stations[a]['temp']
        b +=a1
    c = b/len(names)
    return c
# --------------------------------------------------
def show_all_station_names1(stations):
    names = []
    for name in stations:
        names.append(name.title())
    names.sort()
    return names
def tempmin(stations):
    b=[]
    stations1 = show_all_station_names1(stations)
    for i in range(len(stations1)):
        d = stations1[i].upper()
        a = stations[d]['temp']
        c = [a,d]
        b.append(c)
    return b
def tempmax(stations):
    b=[]
    stations1 = show_all_station_names1(stations)
    for i in range(len(stations1)):
        d = stations1[i].upper()
        a = stations[d]['temp']
        c = [-a,d]
        b.append(c)
    return b
# 6330264821 (30) 113 (2021-03-28 14:53)

def approx_match(stations, name):
    x = ''
    y = []
    for ch in name :
        if ch != ' ' :
            x += ch.lower()
    for k in stations :
        z = ''
        for ch in k :
            if ch != ' ' :
                z += ch.lower()
        if x in z :
            y.append(k)

    return y
def top_k_min_temp_stations(stations, K):
    x = ''
    y = []
    z = []
    for k in stations :
        y.append([stations[k]['temp'],k.lower(),k])
    y.sort()
    if K>len(y) :
        K = len(y)
    for i in range(K) :
        z.append(y[i][2])
    return z
def top_k_max_temp_stations(stations, K):
    x = ''
    y = []
    z = []
    for k in stations :
        y.append([-(stations[k]['temp']),k.lower(),k])
    y.sort()
    if K>len(y) :
        K = len(y)
    for i in range(K) :
        z.append(y[i][2])
    return z
def peak_stations(stations):
    x = []
    lattanasart = []
    longpenrukdo = []
    for k in stations :
        lattanasart.append([(stations[k]['lat']),k])
        longpenrukdo.append([(stations[k]['long']),k])
    lattanasart.sort()
    longpenrukdo.sort()
    x.append(lattanasart[0][1])
    x.append(lattanasart[-1][1])
    x.append(longpenrukdo[0][1])
    x.append(longpenrukdo[-1][1])
    return x
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    x = []
    z = []
    for k in stations :
        lat2 = stations[k]['lat']
        long2 = stations[k]['long']
        y = distance(lat1, long1, lat2, long2)
        x.append([y,k.lower(),k])
    x.sort()
    if K+1>len(stations) :
        K = len(stations)-1
    for i in range(K) :
        z.append(x[i+1][2])
    return z
def average_temp(stations, names):
    x = 0
    for e in names :
        x += stations[e]['temp']
    x = x/len(names)
    return x

# --------------------------------------------------
# 6330265421 (30) 114 (2021-03-28 21:27)

def approx_match(stations, name):
    pv = []
    n = ''
    for e in name:
        if e != ' ': n += e.upper()
    for key in stations:
        m = ''
        for e in key:
            if e != ' ': m += e.upper()
        if n in m: pv.append(key)
    return pv
def top_k_min_temp_stations(stations, K):
    s = []
    for key in stations:
        s.append([stations[key]['temp'],key])
    k = []
    for i in sorted(s):
        k.append(i[1])
    return k[:K]
def top_k_max_temp_stations(stations, K):
    s = []
    for key in stations:
        s.append([-(stations[key]['temp']),key])
    k = []
    for i in sorted(s):
        k.append(i[1])
    return k[:K]
def peak_stations(stations):
    lat,long = [],[]
    for e in stations:
        lat.append([stations[e]['lat'],e])
        long.append([stations[e]['long'],e])
    x = sorted(lat)
    y = sorted(long)
    return [x[0][1],x[-1][1],y[0][1],y[-1][1]]
def k_nearby_stations(stations, main_station, K):
    n,k = [],[]
    for key in stations:
        x = distance(stations[key]['lat'], stations[key]['long'], stations[main_station]['lat'] , stations[main_station]['long'])
        n.append([x,key])
    for i in sorted(n):
        k.append(i[1])
    return k[1:K+1]
def average_temp(stations, names):
    sum_temp = 0
    for e in names:
        sum_temp += stations[e]['temp']
    return sum_temp/len(names)
# --------------------------------------------------
# 6330266021 (25.5) 115 (2021-03-29 15:54)

def approx_match(stations, name):
    names = []
    for res in stations:
        if res.lower().find(name.lower()) >= 0:
            names.append(res)
    names.sort()
    return names
def top_k_min_temp_stations(stations, K):
    names = []
    temps = []
    for res in stations:
        temps.append(stations[res]['temp'])
    temps.sort()
    for index in range(K):
        for res in stations:
            if stations[res]['temp'] == temps[index]:
                names.append(res)
    return names
def top_k_max_temp_stations(stations, K):
    names = []
    temps = []
    for res in stations:
        temps.append(stations[res]['temp'])
    temps.sort()
    temps.reverse()
    for index in range(K):
        for res in stations:
            if stations[res]['temp'] == temps[index]:
                names.append(res)
    return names
def peak_stations(stations):
    names = []
    latitudes = []
    longitudes = []
    for res in stations:
        latitudes.append(stations[res]['lat'])
    for res in stations:
        longitudes.append(stations[res]['long'])
    for res in stations:
        if stations[res]['lat'] == min(latitudes):
            names.append(res)
        if stations[res]['lat'] == max(latitudes):
            names.append(res)
    for res in stations:
        if stations[res]['long'] == min(longitudes):
            names.append(res)
        if stations[res]['long'] == max(longitudes):
            names.append(res)
    return names
def k_nearby_stations(stations, main_station, K):
    names = []
    kilos = []
    for res in stations:
        kilos.append(distance(stations[main_station]['lat'], stations[main_station]['long'], stations[res]['lat'], stations[res]['long']))
    kilos.sort()
    for index in range(K):
        for res in stations:
            if distance(stations[main_station]['lat'], stations[main_station]['long'], stations[res]['lat'], stations[res]['long']) == kilos[index+1]:
                names.append(res)
    return names
def average_temp(stations, names):
    temps = []
    for res in stations:
        if res in names:
            temps.append(stations[res]['temp'])
    return (sum(temps) / len(names))


# --------------------------------------------------
# 6330267721 (30) 116 (2021-03-28 10:20)

def approx_match(stations, name):
    show = []
    names = ''
    for i in name :
        if i != ' ' :
            names += i
    for i in stations :
        if names.lower() in i.lower() :
            show.append(i)
    return show
def top_k_min_temp_stations(stations, K):
    data = []
    show = []
    for i in stations :
        data.append([stations[i]['temp'],i])
    sort_data = sorted(data)[:K]
    for i in sort_data :
        show.append(i[1])
    return show
def top_k_max_temp_stations(stations, K):
    data = []
    show = []
    for i in stations :
        data.append([-stations[i]['temp'],i])
    sort_data = sorted(data)[:K]
    for i in sort_data :
        show.append(i[1])
    return show
def peak_stations(stations):
    show =['lat_min', 'lat_max', 'long_min', 'long_max']
    compare = [0,1000,0,1000]
    for i in stations :
        if stations[i]['lat'] > compare[0] :
            compare[0] = stations[i]['lat']
            show[1] = i
        if stations[i]['lat'] < compare[1] :
            compare[1] = stations[i]['lat']
            show[0] = i
        if stations[i]['long'] > compare[2] :
            compare[2] = stations[i]['long']
            show[3] = i
        if stations[i]['long'] < compare[3] :
            compare[3] = stations[i]['long']
            show[2] = i
    return show
def k_nearby_stations(stations, main_station, K):
    show = []
    data = {}
    perform = []
    for i in stations :
        for e in stations :
            if i != e :
                if i in data :
                    data[i][e] =  distance(stations[i]['lat'], stations[i]['long'], stations[e]['lat'], stations[e]['long'])
                else :
                    data[i] = {e : distance(stations[i]['lat'], stations[i]['long'], stations[e]['lat'], stations[e]['long'])}
    for i in data[main_station] :
        show.append([data[main_station][i],i])
    show.sort()
    for i in show :
        perform.append(i[1])
    return  perform[:K]
def average_temp(stations, names):
    result = 0
    for i in stations :
        if i in names :
            result += stations[i]['temp']
    result = result/len(names)
    return result



# --------------------------------------------------
# 6330268321 (30) 117 (2021-03-29 21:08)

def approx_match(stations,name):
    name_inuse=''
    station_inusestr=''
    station_inusekey=[] #list key modify
    station_key=[] #list key not modify
    station_inuseans=[]
    name=name.upper()

    for e in name:
        if 'A'<=e<='Z':
            name_inuse+=e
    for e in stations:
        station_key.append(e)
        station_inusestr=''
        for f in e:
            if 'A'<=f<='Z':
                station_inusestr+=f
        station_inusekey.append(station_inusestr)
    for e in station_inusekey:
        if name_inuse in e:
            j=station_inusekey.index(e)
            station_inuseans.append(station_key[j])
    return station_inuseans
#------------------------------------------------------------
def top_k_min_temp_stations(stations, K):
    min_temp=[]
    min_stations=[]
    for e in stations:
        min_temp.append([stations[e]['temp'],e])
        min_temp.sort()
    for i in range(K):
        if i >=len(min_temp):
            break
        else: min_stations.append(min_temp[i][1])

    return min_stations
#------------------------------------------------------------
def top_k_max_temp_stations(stations, K):
    u=[]
    max_temp=[]
    max_stations=[]
    for e in stations:
        u.append([-stations[e]['temp'],e])
        u.sort()
    for i in range(len(u)):
        max_temp.append([-u[i][0],u[i][1]])
    for i in range(K):
        if i >=len(max_temp):
            break
        else: max_stations.append(max_temp[i][1])
    return max_stations
#-------------------------------------------------------------
def peak_stations(stations):
    max_latw=[]
    max_lat=[]
    min_latw=[]
    min_lat=[]
    max_longw=[]
    max_long=[]
    min_longw=[]
    min_long=[]

    for e in stations:
        min_latw.append([stations[e]['lat'],e])
        min_latw.sort()
        min_longw.append([stations[e]['long'],e])
        min_longw.sort()
        max_latw.append([-stations[e]['lat'],e])
        max_latw.sort()
        max_longw.append([-stations[e]['long'],e])
        max_longw.sort()
    for i in range(len(min_latw)):
        min_lat.append([min_latw[i][1],min_latw[i][0]])
    for i in range(len(min_longw)):
        min_long.append([min_longw[i][1],min_longw[i][0]])
    for i in range(len(max_longw)):
        max_long.append([max_longw[i][1],-max_longw[i][0]])
    for i in range(len(max_latw)):
        max_lat.append([max_latw[i][1],-max_latw[i][0]])
    return [min_lat[0][0],max_lat[0][0],min_long[0][0],max_long[0][0]]
#----------------------------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    nearbystations=[]
    u=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for e in stations:
        lat2=stations[e]['lat']
        long2=stations[e]['long']
        if e != main_station:
            u.append([distance(lat1, long1, lat2, long2),e])
            u.sort()
    for i in range(K):
        nearbystations.append(u[i][1])
    return nearbystations
#----------------------------------------------------------------------
def average_temp(stations, names):
    totaltemp=0
    for e in names:
        totaltemp+=stations[e]['temp']
    return totaltemp/len(names)

# --------------------------------------------------
# 6330270521 (28.74) 118 (2021-03-29 20:02)

def approx_match(stations, name):
    l = []
    y = name.replace(' ', '')
    for i in stations :
        x = i.replace(' ', '')
        if y.lower() in x.lower() :
            l.append(i)
    return l
def top_k_min_temp_stations(stations, K):
    l = []
    for i in stations :
        l.append([stations[i]['temp'],i])
    l.sort(key = lambda x: x[1])
    l.sort()
    if K > len(l) :
        K = len(l)
    l2 = []
    for i in range(K) :
        l2.append(l[i][1])
    return l2
def top_k_max_temp_stations(stations, K):
    l = []
    for i in stations :
        l.append([stations[i]['temp'],i])
    l.sort(key = lambda x: x[1])
    l.sort(reverse=True)
    if K > len(l) :
        K = len(l)
    l2 = []
    for i in range(K) :
        l2.append(l[i][1])
    return l2
def peak_stations(stations):
    l = []
    lat = []
    long = []
    for i in stations :
        lat.append([stations[i]['lat'],i])
        long.append([stations[i]['long'],i])
    lat.sort()
    long.sort()
    l.append(lat[0][1])
    l.append(lat[-1][1])
    l.append(long[0][1])
    l.append(long[-1][1])
    return l
def k_nearby_stations(stations, main_station, K):
    l = []
    latmain = stations[main_station]['lat']
    longmain = stations[main_station]['long']
    for i in stations :
        if i != main_station :
            latnear = stations[i]['lat']
            longnear = stations[i]['long']
            l.append([distance(latmain, longmain, latnear, longnear),i])
    l.sort(key = lambda x: x[1])
    l.sort()
    if len(l) < K :
        K = len(l)
    near = []
    for i in range(K) :
        near.append(l[i][1])
    return near
def average_temp(stations, names):
    sum = 0
    for i in names :
        sum += stations[i]['temp']
    avg = sum/len(names)
    return avg


# --------------------------------------------------
# 6330271121 (30) 119 (2021-03-28 21:58)

def approx_match(stations, name):
    nname = name.upper().split()
    nn = ''.join(nname)
    lis = []
    for key in stations:
        ke = key.upper().split()
        k = ''.join(ke)
        if k.find(nn) > 0:
            lis.append(key)
    return lis
def top_k_min_temp_stations(stations, K):
    lis =[]
    for key in stations:
        lis.append([stations[key]['temp'],key])
    lis.sort()
    lis = lis[:K:]
    sta = []
    for tem,stat in lis:
        sta.append(stat)
    return sta
def top_k_max_temp_stations(stations, K):
    lis =[]
    for key in stations:
        lis.append([-stations[key]['temp'],key])
    lis.sort()
    lis = lis[:K:]
    sta = []
    for tem,stat in lis:
        sta.append(stat)
    return sta
def peak_stations(stations):
    minlat = 10**1000
    maxlat = -(10**1000)
    minlong = 10**1000
    maxlong = -(10**1000)
    lis = [0]*4
    for key in stations:
        if stations[key]['lat'] < minlat:
            lis[0] = key
            minlat = stations[key]['lat']
        if stations[key]['lat'] > maxlat:
            lis[1] = key
            maxlat = stations[key]['lat']
        if stations[key]['long'] < minlong:
            lis[2] = key
            minlong = stations[key]['long']
        if stations[key]['long'] > maxlong:
            lis[3] = key
            maxlong = stations[key]['long']
    return lis
def k_nearby_stations(stations, main_station, K):
    lat2 = stations[main_station]['lat']
    long2 = stations[main_station]['long']
    lis = []
    for key in stations:
        lat1 = stations[key]['lat']
        long1 = stations[key]['long']
        dis = distance(lat1,long1,lat2,long2)
        lis.append([dis,key])
    lis.sort()
    lis = lis[1:K+1:]
    sta = []
    for dis,stat in lis:
        sta.append(stat)
    return sta
def average_temp(stations, names):
    summ = 0
    for e in names:
        summ += stations[e]['temp']
    ave = summ/len(names)
    return ave

# --------------------------------------------------
# 6330272821 (30) 120 (2021-03-28 23:27)

def approx_match(stations, name):
    real_name = []
    result = []
    for e in name:
        if e.isalpha(): real_name.append(e.upper())
    real_name = "".join(real_name)
    for e in stations:
        if real_name in e:
            result.append(e)
    return result
def top_k_min_temp_stations(stations, K):
    sta_tem = []
    result = []
    for k,v in stations.items():
        sta_tem.append([v['temp'], k])
    sta_tem = sorted(sta_tem,key=lambda sl: (sl[0],sl[1]))
    if K < len(stations):
        sta_tem = sta_tem[:K]
    for e in sta_tem:
        result.append(e[1])
    return result
def top_k_max_temp_stations(stations, K):
    sta_tem = []
    result = []
    for k,v in stations.items():
        sta_tem.append([v['temp'], k])
    sta_tem = sorted(sta_tem,key=lambda sl: (-sl[0],sl[1]))
    if K < len(stations):
        sta_tem = sta_tem[:K]
    for e in sta_tem:
        result.append(e[1])
    print(sta_tem)
    return result
def peak_stations(stations):
    result = []
    lat_dick = {}
    long_dick = {}
    lat_list = []
    long_list = []
    for k, v in stations.items():
        lat_dick[v['lat']] = k
        lat_list.append(v['lat'])
        long_dick[v['long']] = k
        long_list.append(v['long'])
    lat_list = sorted(lat_list)
    long_list = sorted(long_list)
    result.append(lat_dick[lat_list[0]])
    result.append(lat_dick[lat_list[-1]])
    result.append(long_dick[long_list[0]])
    result.append(long_dick[long_list[-1]])
    return result
def k_nearby_stations(stations, main_station, K):
    result = []
    near_dick = []
    for k, v in stations.items():
        near_dick.append([distance(v['lat'], v['long'], stations[main_station]['lat'], stations[main_station]['long']), k])
    near_dick = sorted(near_dick)
    if len(near_dick) < K:
        for i in range(len(near_dick)-1):
            result.append(near_dick[i+1][1])
    else:
        for i in range(K):
            result.append(near_dick[i+1][1])
    return result
def average_temp(stations, names):
    result = 0
    for e in names:
        result += stations[e]['temp']
    return result/len(names)

# --------------------------------------------------
# 6330273421 (30) 121 (2021-03-26 23:08)

def approx_match(stations, name):
    name=name.upper()
    out=[]
    name=''.join(name.split())
    for e in stations:
        if name in ''.join(e.split()):
            out.append(e)
    return out
def top_k_min_temp_stations(stations, K):
    t_st=[]
    num=[]
    for e in stations:
        num.append(e)
        temp=stations[e]['temp']
        t_st.append([float(temp),e])
    t_st.sort()
    out=[]
    if K<len(num):
        for i in range(K):
            out.append(t_st[i][1])
    else:
        for i in range(len(num)):
            out.append(t_st[i][1])
    return out
def top_k_max_temp_stations(stations, K):
    t_st=[]
    num=[]
    for e in stations:
        num.append(e)
        temp=stations[e]['temp']
        t_st.append([-float(temp),e])
    t_st.sort()
    out=[]
    if K<len(num):
        for i in range(K):
            out.append(t_st[i][1])
    else:
        for i in range(len(num)):
            out.append(t_st[i][1])
    return out
def peak_stations(stations):
    lat_st=[]
    long_st=[]
    for e in stations:
        lat=stations[e]['lat']
        lat_st.append([float(lat),e])
        long=stations[e]['long']
        long_st.append([float(long),e])
    lat_st.sort()
    long_st.sort()
    out=[lat_st[0][1],lat_st[-1][1],long_st[0][1],long_st[-1][1]]
    return out
def k_nearby_stations(stations, main_station, K):
    main_station=main_station.upper()
    d_st=[]
    out=[]
    num=[]
    lat2=stations[main_station]['lat']
    long2=stations[main_station]['long']
    for e in stations:
        num.append(e)
        lat1=stations[e]['lat']
        long1=stations[e]['long']
        d=distance(lat1, long1, lat2, long2)
        d_st.append([d,e])
    d_st.sort()
    if K<len(num):
        for i in range(K):
            out.append(d_st[i+1][1])
    else:
        for i in range(len(num)-1):
            out.append(d_st[i+1][1])
    return out
def average_temp(stations, names):
    sm=0
    for e in names:
        temp=stations[e]['temp']
        sm+=temp
    avg=sm/len(names)
    return avg

# --------------------------------------------------
# 6330274021 (30) 122 (2021-03-29 18:36)

def approx_match(stations, name):
    namef = ''
    station_ap = []
    name = name.strip().upper()
    for e in name:
        if 'A'<= e<= 'Z':
            namef += e
    for n in stations:
        n1 = n
        n1 = n1.strip().upper()
        namef0 = ''
        for e in n1:
            if 'A'<= e<= 'Z':
                namef0 += e
        if namef in namef0:
            station_ap.append(n)
    return station_ap
def top_k_min_temp_stations(stations, K):
    ts = []
    min_k = []
    for n in stations:
        ts.append([stations[n]['temp'],n])
    ts.sort()
    ts = ts[:K]
    for i in range(len(ts)):
        min_k.append(ts[i][1])
    return min_k
def top_k_max_temp_stations(stations, K):
    ts = []
    max_k = []
    for n in stations:
        ts.append([stations[n]['temp']*-1,n])
    ts.sort()
    for i in range(len(ts)):
        ts[i][0] *= -1
    ts = ts[:K]
    for i in range(len(ts)):
        max_k.append(ts[i][1])
    return max_k
def peak_stations(stations):
    lat_s = []
    long_s = []
    for e in stations:
        lat_s.append([stations[e]['lat'],e])
        long_s.append([stations[e]['long'],e])
    lat_s.sort()
    long_s.sort()
    max_lat = lat_s[-1][1]
    min_lat = lat_s[0][1]
    max_long = long_s[-1][1]
    min_long = long_s[0][1]
    peak = [min_lat,max_lat,min_long,max_long]
    return peak
def k_nearby_stations(stations, main_station, K):
    ds = []
    near = []
    for e in stations:
        d = abs(distance(stations[main_station]['lat'],stations[main_station]['long'],stations[e]['lat'],\
                         stations[e]['long']))
        ds.append([d,e])
    ds.sort()
    ds = ds[1:K+1]
    for i in range(len(ds)):
        near.append(ds[i][1])
    return near
def average_temp(stations, names):
    sum0 = 0
    avg = 0
    for e in names:
        sum0 += stations[e]['temp']
    if names != []:
        avg = sum0/len(names)
    else:
        avg = 0
    return avg

# --------------------------------------------------
# 6330275721 (28.74) 123 (2021-03-29 16:12)

def approx_match(stations, name):
    new_name = ''
    for i in range(len(name)):
        if name[i] == ' ':
            new_name += ''
        else:
            new_name += name[i]
    new_name = new_name.upper()
    # ----------------------------------------------
    stt = []
    for key in stations:
        sub_stt = ''
        for i in range(len(key)):
            if key[i] == ' ':
                sub_stt += ''
            else:
                sub_stt += key[i]
        sub_stt = sub_stt.upper()
        stt.append(sub_stt)
    # ----------------------------------------------
    real_stt = []
    for key in stations:
        real_stt.append(key)
    # ----------------------------------------------
    ap_m = []
    for i in range(len(real_stt)):
        if new_name in stt[i]:
            ap_m.append(real_stt[i])
    return ap_m
def top_k_min_temp_stations(stations, K):
    all_temp_stt = []
    for key in stations:
        keytemp = []
        keytemp.append(stations[key]['temp'])
        keytemp.append(key)
        all_temp_stt.append(keytemp)
    all_temp_stt.sort()
    # ----------------------------------------------
    t_min_stt = []
    for t in all_temp_stt:
        t_min_stt.append(t[1])
    t_min_stt = t_min_stt[0:K:1]
    return t_min_stt
def top_k_max_temp_stations(stations, K):
    all_temp_stt = []
    for key in stations:
        keytemp = []
        keytemp.append(stations[key]['temp'])
        keytemp.append(key)
        all_temp_stt.append(keytemp)
    all_temp_stt.sort()
    # ----------------------------------------------
    t_max_stt = []
    for t in all_temp_stt:
        t_max_stt.append(t[1])
    t_max_stt = t_max_stt[-1:-(K+1):-1]
    return t_max_stt
def peak_stations(stations):
    latitude = {}; longitude = {}
    for key in stations:
        latitude[key] = stations[key]['lat']
        longitude[key] = stations[key]['long']
    # ----------------------------------------------
    list_lat = []; list_long = []
    for key in latitude:
        list_lat.append([latitude[key],key])
    list_lat.sort()
    for key in longitude:
        list_long.append([longitude[key],key])
    list_long.sort()
    # ----------------------------------------------
    p_stt = []
    min_lat = list_lat[0][1]
    p_stt.append(min_lat)
    max_lat = list_lat[-1][1]
    p_stt.append(max_lat)
    min_long = list_long[0][1]
    p_stt.append(min_long)
    max_long = list_long[-1][1]
    p_stt.append(max_long)
    return p_stt
def k_nearby_stations(stations, main_station, K):
    dist = {}
    for key in stations:
        dist[key] = distance(stations[main_station]['lat']\
                        , stations[main_station]['long']\
                        , stations[key]['lat']\
                        , stations[key]['long'])
    # ----------------------------------------------
    alln_stt = []
    for key in dist:
        sub_alln_stt = []
        sub_alln_stt.append(dist[key])
        sub_alln_stt.append(key)
        alln_stt.append(sub_alln_stt)
    alln_stt.sort()
    # ----------------------------------------------
    n_stt = []
    for i in range(K):
        n_stt.append(alln_stt[i+1][1])
    return n_stt
def average_temp(stations, names):
    all_temp_stt = {}
    temp = []
    sums = 0
    N = len(names)
    for key in stations:
        all_temp_stt[key] = stations[key]['temp']
    # ----------------------------------------------
    for key in names:
        temp.append(float(all_temp_stt[key]))
    # ----------------------------------------------
    for e in temp:
        sums += e
    a_t = sums/N
    return a_t

# --------------------------------------------------
# 6330276321 (30) 124 (2021-03-27 02:56)

def approx_match(stations, name):
    new_stations = {}
    result = []
    for e in stations :
        x = ''
        for y in e :
            if 'A' <= y <= 'z' :
                x += y.upper()
        new_stations[x] = e
    n = ''
    for e in name :
        if 'A' <= e <= 'z' :
            n += e.upper()
    for e in new_stations :
        if n.upper() in e :
            result.append(new_stations[e])
    return result
def top_k_min_temp_stations(stations, K):
    temp_n_name = []
    result = []
    for e in stations :
        temp_n_name.append([stations[e]['temp'], e])
    temp_n_name.sort()
    top_K_stations = temp_n_name[0:K]
    for x, y in top_K_stations :
        result.append(y)
    return result
def top_k_max_temp_stations(stations, K):
    temp_n_name = []
    result = []
    for e in stations :
        temp_n_name.append([stations[e]['temp']*-1, e])
    temp_n_name.sort()
    top_K_stations = temp_n_name[0:K]
    for x, y in top_K_stations :
        result.append(y)
    return result
def peak_stations(stations):
    lat_list = []
    long_list = []
    for e in stations :
        lat_list.append([stations[e]['lat'], e])
        long_list.append([stations[e]['long'], e])
    lat_list.sort()
    long_list.sort()
    a = lat_list[0]
    b = lat_list[-1]
    c = long_list[0]
    d = long_list[-1]
    result = [a[1], b[1], c[1], d[1]]
    return result
def k_nearby_stations(stations, main_station, K):
    distance_list = []
    result = []
    for e in stations :
        d = distance(stations[e]['lat'], stations[e]['long'], \
                     stations[main_station]['lat'], stations[main_station]['long'])
        distance_list.append([d, e])
    distance_list.sort()
    top_K_staions = distance_list[1:K+1]
    for x, y in top_K_staions :
        result.append(y)
    return result
def average_temp(stations, names):
    sum_temp = 0
    for e in names :
        sum_temp += stations[e]['temp']
    avg_temp = sum_temp / len(names)
    return avg_temp



# --------------------------------------------------
# 6330277021 (28.74) 125 (2021-03-29 23:25)

def approx_match(stations, name):
    x1 = []
    s1 = ''
    for ch in name:
        if 'A' <= ch.upper() <= 'Z':
            s1 += ch
    for k in stations:
        s2 = ''
        for ch2 in k:
            if 'A' <= ch2.upper() <= 'Z':
                s2 += ch2
        if s1.upper() in s2.upper():
            x1.append(k)
    return x1
def top_k_min_temp_stations(stations, K):
    x2_min = []
    for k in stations:
        x2_min.append([stations[k]['temp'], k])
    x2_min.sort()
    x2_min = x2_min[:K:]
    x2min = []
    for e in x2_min:
        x2min.append(e[1])
    return x2min
def top_k_max_temp_stations(stations, K):
    x2_max = []
    for k in stations:
        x2_max.append([stations[k]['temp'], k])
    x2_max.sort()
    x2_max = x2_max[::-1]
    x2_max = x2_max[:K:]
    x2max = []
    for e in x2_max:
        x2max.append(e[1])
    return x2max
def peak_stations(stations):
    x3_lat = []
    for k in stations:
        x3_lat.append([stations[k]['lat'], k])
    x3_lat.sort()
    min_lat = x3_lat[0][1]
    max_lat = x3_lat[-1][1]
    x3_long = []
    for k in stations:
        x3_long.append([stations[k]['long'], k])
    x3_long.sort()
    min_long = x3_long[0][1]
    max_long = x3_long[-1][1]
    return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    x4 = []
    for k in stations:
        x4.append([distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long']), k])
    x4.sort()
    x4_re = []
    for e in x4:
        x4_re.append(e[1])
    if main_station in x4_re:
        x4_re.remove(main_station)
    if len(x4) <= K:
        return x4_re
    else:
        return x4_re[:K:]
def average_temp(stations, names):
    s = 0
    for e in names:
        s += stations[e]['temp']
    return s/len(names)


# --------------------------------------------------
# 6330278621 (28.74) 126 (2021-03-27 13:32)

def approx_match(stations, name):
    new_name = name.upper()
    Name = ''
    for e in new_name:
        if 'A'<=e<='Z':
            Name += e
    newstations = []
    for e in stations:
        string = ''
        for i in e:
            if 'A'<=i<='z':
                string += i.upper()
        newstations.append(string)
    show = []
    list_of_stations = []
    for e in stations:
        list_of_stations.append(e)
    for i in range(len(list_of_stations)):
        if Name in newstations[i]:
            show.append(list_of_stations[i])
    return show
def top_k_min_temp_stations(stations, K):
    temp_n_sta = []
    for e in stations:
        temp_n_sta.append([stations[e]['temp'],e])
    temp_n_sta.sort()
    sta_n_temp =[]
    for i in range(len(temp_n_sta)):
        sta_n_temp.append([temp_n_sta[i][0],temp_n_sta[i][1]])
    show = []
    for e in sta_n_temp:
        show.append(e[1])
    show = show[:K]
    return show
def top_k_max_temp_stations(stations, K):
    temp_n_sta = []
    for e in stations:
        temp_n_sta.append([stations[e]['temp'],e])
    temp_n_sta.sort()
    sta_n_temp =[]
    for i in range(len(temp_n_sta)):
        sta_n_temp.append([temp_n_sta[i][0],temp_n_sta[i][1]])
    show = []
    for e in sta_n_temp:
        show.append(e[1])
    show = show[-1:-K-1:-1]
    return show
def peak_stations(stations):
    dict_lat = {}
    dict_long = {}
    for e in stations:
        dict_lat[e] = stations[e]['lat']
        dict_long[e] = stations[e]['long']
    lat = []
    long = []
    for e in dict_lat:
        lat.append([dict_lat[e],e])
    for e in dict_long:
        long.append([dict_long[e],e])
    lat.sort()
    long.sort()
    peak_sta = []
    peak_sta.append(lat[0][1])
    peak_sta.append(lat[len(lat)-1][1])
    peak_sta.append(long[0][1])
    peak_sta.append(long[len(long)-1][1])

    return peak_sta
def k_nearby_stations(stations, main_station, K):
    dict_distance = {}
    for e in stations:
        dict_distance[e] = distance(stations[main_station]['lat'],stations[main_station]['long']\
                                    ,stations[e]['lat'],stations[e]['long'])
    shows = []
    for e in dict_distance:
        shows.append([dict_distance[e],e])
    shows.sort()
    show = []
    for i in range(K):
        show.append(shows[i+1][1])
    return show
def average_temp(stations, names):
    dict_temp = {}
    for e in stations:
        dict_temp[e] = stations[e]['temp']
    temp = []
    for e in names:
        temp.append(float(dict_temp[e]))
    sums = 0
    for i in range(len(temp)):
        sums += temp[i]
    return sums/len(names)

# --------------------------------------------------
# 6330279221 (30) 127 (2021-03-29 14:29)

def approx_match(stations, name):
    n = name.upper()
    s = ''
    for i in n:
        if i == ' ':
            s += ''
        else:
            s += i
    station = []
    for key in stations:
        k = ''
        for i in key:
            if i == ' ':
                k += ''
            else:
                k += i
        if s in k.upper():
            station.append(key)
    return station
def top_k_min_temp_stations(stations, K):
    temp = []
    for key in stations:
        temp.append([stations[key]['temp'],key])
    temp.sort()
    nameonly = []
    for i in temp:
        nameonly.append(i[1])
    return nameonly[:K]
def top_k_max_temp_stations(stations, K):
    temp = []
    for key in stations:
        temp.append([-stations[key]['temp'],key])
    temp.sort()
    nameonly = []
    for i in temp:
        nameonly.append(i[1])
    return nameonly[:K]
def peak_stations(stations):
    peak = []
    lat = []
    for i in stations:
        lat.append([stations[i]['lat'],i])
    lat.sort()
    peak.append(lat[0][1])
    peak.append(lat[-1][1])
    long = []
    for k in stations:
        long.append([stations[k]['long'],k])
    long.sort()
    peak.append(long[0][1])
    peak.append(long[-1][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    dis = []
    for i in stations:
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        dis.append([distance(lat1, long1, lat2, long2), i])
    dis.sort()
    disna = []
    for i in dis:
        disna.append(i[1])
    return disna[1:K+1]
def average_temp(stations, names):
    total = 0
    for e in names:
        total += stations[e]['temp']
    return total/len(names)


# --------------------------------------------------
# 6330280821 (28.74) 128 (2021-03-29 21:34)

def approx_match(stations, name):
    n = ""
    for e in name:
        if e != " ":
            n += e.upper()
    s = []
    for a in stations:
        if n in a:
            s.append(a)
    return s
def top_k_min_temp_stations(stations, K):
    result = []
    for a in stations:
        result.append([stations[a]['temp'],a])
    result.sort()
    c = result[:K]
    b = []
    for i in range(len(c)):
        b.append(c[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    result = []
    for a in stations:
        result.append([stations[a]['temp'],a])
    result.sort()
    p = result[::-1]
    q = p[:K]
    r = []
    for i in range(len(q)):
        r.append(q[i][1])
    return r
def peak_stations(stations):
    peak = []
    for n in stations:
        peak.append([stations[n]['lat'],n])
    peak.sort()
    b = []
    b.append(peak[0][1])
    b.append(peak[-1][1])
    peak2 = []
    for n in stations:
        peak2.append([stations[n]['long'],n])
    peak2.sort()
    c = []
    c.append(peak2[0][1])
    c.append(peak2[-1][1])
    return b+c
def k_nearby_stations(stations, main_station, K):
    d = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for n in stations:
        lat2 = stations[n]['lat']
        long2 = stations[n]['long']
        dis = distance(lat1, long1, lat2, long2)
        d.append([dis,n])
    d.sort()
    s = d[:K+1]
    l = []
    for i in range(len(s)):
        l.append(s[i][1])
    return l[1:]
def average_temp(stations, names):
    s = 0
    for n in names:
        s += stations[n]['temp']
    return s/len(names)



# --------------------------------------------------
# 6330281421 (30) 129 (2021-03-29 21:05)

def approx_match(stations, name):
    name=convert_str(name)
    #print(name)
    approx_match=[]
    for names in stations:
        if name in convert_str(names):
            approx_match.append(names)
    return approx_match
def top_k_min_temp_stations(stations, K):
    K=min(K,len(stations))
    temp_list=[]
    for station in stations:
        temp_list.append([stations[station]['temp'],station])
    temp_list.sort()
    station_temp=[]
    for i in range(K):
        station_temp.append(temp_list[i][1])
    return station_temp
def top_k_max_temp_stations(stations, K):#need fix bug
    K=min(K,len(stations))
    temp_list=[]
    for station in stations:
        temp_list.append([-stations[station]['temp'],station])
    temp_list.sort()
    station_temp=[]
    for i in range(K):
        station_temp.append(temp_list[i][1])
    return station_temp
def peak_stations(stations):
    lat_list=[]
    long_list=[]
    for station in stations:
        lat_list.append([stations[station]['lat'],station])
    lat_list.sort()
    for station in stations:
        long_list.append([stations[station]['long'],station])
    long_list.sort()
    return [lat_list[0][1],lat_list[-1][1],long_list[0][1],long_list[-1][1]]
def k_nearby_stations(stations, main_station, K):
    K=min(K,len(stations))
    main_station=main_station.upper()
    b=[stations[main_station]['lat'],stations[main_station]['long']]
    nearby_list=[]
    for station in stations:
        e=[stations[station]['lat'],stations[station]['long']]
        nearby_list.append([ distance(b[0], b[1], e[0], e[1]) , station])
        #nearby_list.append([   (b[0]-e[0])**2 + (b[1]-e[1])**2 , station])
    nearby_list.sort()
    nearby_list.pop(0)
    station_dis=[]
    for i in range(K):
        station_dis.append(nearby_list[i][1])
    return station_dis
def average_temp(stations, names):
    s=[]
    for station in names:
        s.append(stations[station]['temp'])
    return mean(s)

# --------------------------------------------------
def convert_str(text):
    new_text=''
    for i in text:
        if 'A'<=i.upper()<='Z':
            new_text+=i.upper()
        elif i==' ':
            new_text+=''
        else:
            new_text+=i
    return new_text
#
# 6330282021 (30) 130 (2021-03-28 17:27)

def approx_match(stations, name):
    result = []
    name = name.strip().upper()
    n = ''
    for e in name:
        if 'A' <= e <= 'Z':
            n += e
    for k in stations:
        n_station = ''
        for a in k:
            if 'A' <= a <= 'Z' or 'a' <= a <= 'z':
                n_station += a
        if n in n_station.upper():
            result.append(k)
    return result
def top_k_min_temp_stations(stations, K):
    t = []
    for k in stations:
        t.append([stations[k]['temp'],k])
    t.sort()
    result = []
    for temp,st in t[:K]:
        result.append(st)
    return result
def top_k_max_temp_stations(stations, K):
    t = []
    for k in stations:
        t.append([-stations[k]['temp'],k])
    t.sort()
    result = []
    for temp,st in t[:K]:
        result.append(st)
    return result
def peak_stations(stations):
    data_lat = []
    data_long = []
    for k in stations:
        data_lat.append([stations[k]['lat'],k])
        data_long.append([stations[k]['long'],k])
    data_lat.sort()
    data_long.sort()
    min_lat = data_lat[0][1]
    max_lat = data_lat[-1][1]
    min_long = data_long[0][1]
    max_long = data_long[-1][1]
    result = [min_lat,max_lat,min_long,max_long]
    return result
def k_nearby_stations(stations, main_station, K):
    d = []
    for k in stations:
        dis = distance(stations[main_station]['lat'],stations[main_station]['long'],stations[k]['lat'],stations[k]['long'])
        d.append([dis,k])
    d.sort()
    result = []
    for dist,st in d[1:K+1]:
        result.append(st)
    return result
def average_temp(stations, names):
    total_temp = 0
    for e in names:
        total_temp += stations[e]['temp']
    avg_temp = total_temp/len(names)
    return avg_temp


# --------------------------------------------------
# 6330283721 (28.74) 131 (2021-03-26 22:26)

def approx_match(stations, name):
    a=""
    b=[]
    for c in name:
        if c == " ":
            a += ""
        else:
            a += c.upper()
    for c in stations:
        if a in c:
            b.append(c)
    return b
def top_k_min_temp_stations(stations, K):
    temp1=[]
    temp2=[]
    for c in stations:
        temp1.append([stations[c]['temp'],c])
    temp1=sorted(temp1,key=lambda l:(l[0],l[1]))[:K]
    for i in range(len(temp1)):
        temp2.append(temp1[i][1])
    return temp2
def top_k_max_temp_stations(stations, K):
    temp1=[]
    temp2=[]
    for c in stations:
        temp1.append([stations[c]['temp'],c])
    temp1=sorted(temp1,key=lambda l:(l[0],l[1]),reverse=True)[:K]
    for i in range(len(temp1)):
        temp2.append(temp1[i][1])
    return temp2
def peak_stations(stations):
    lat=[]
    long=[]
    peak=[]
    for c in stations:
        lat.append([stations[c]['lat'],c])
        long.append([stations[c]['long'],c])
    lat=sorted(lat)
    long=sorted(long)
    peak.append(lat[0][1])
    peak.append(lat[-1][1])
    peak.append(long[0][1])
    peak.append(long[-1][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    dis=[]
    near=[]
    a=stations[main_station]['lat']
    b=stations[main_station]['long']
    for k in stations:
        dis.append([distance(stations[k]['lat'], stations[k]['long'], a, b), k])
    dis.remove([0, main_station])
    dis=sorted(dis,key=lambda l:(l[0],l[1]))[:K]
    for i in range(len(dis)):
        near.append(dis[i][1])
    return near
def average_temp(stations, names):
    u=0
    for c in names:
        u+=stations[c]['temp']
    u=u/len(names)
    return u
# --------------------------------------------------
# 6330284321 (30) 132 (2021-03-29 12:39)

def approx_match(stations, name):
    name = "".join(name.split(" ")).upper()
    ans = []
    for prov in stations:
        if name in prov:
            ans.append(prov)
    return ans
def top_k_min_temp_stations(stations, K):
    tmp = []
    for prov in stations:
        tmp.append([stations[prov]['temp'], prov])
    tmp.sort()
    ans = []
    for i in range(min(K, len(stations))):
        ans.append(tmp[i][1])
    return ans
def top_k_max_temp_stations(stations, K):
    tmp = []
    for prov in stations:
        tmp.append([-stations[prov]['temp'], prov])
    tmp.sort()
    ans = []
    for i in range(min(K, len(stations))):
        ans.append(tmp[i][1])
    return ans
def peak_stations(stations):
    lat = []
    lng = []
    for prov in stations:
        lat.append([stations[prov]['lat'], prov])
        lng.append([stations[prov]['long'], prov])
    lat.sort()
    lng.sort()
    return [lat[0][1], lat[len(stations) - 1][1], lng[0][1], lng[len(stations) - 1][1]]
def k_nearby_stations(stations, main_station, K):
    tmp = []
    for prov in stations:
        lat1 = stations[main_station]['lat']
        lng1 = stations[main_station]['long']
        lat2 = stations[prov]['lat']
        lng2 = stations[prov]['long']
        tmp.append([distance(lat1, lng1, lat2, lng2), prov])
    tmp.sort()
    ans = []
    for i in range(1, min(K+1, len(stations))):
        ans.append(tmp[i][1])
    return ans
def average_temp(stations, names):
    sum = 0
    for prov in names:
        sum += stations[prov]['temp']
    sum /= len(names)
    return sum




# --------------------------------------------------
# 6330286621 (28.74) 133 (2021-03-28 22:21)

def approx_match(stations, name):
    stations_match=[]
    name= name.replace(" ","")
    for i in stations:
        s=i
        s=s.replace(" ","")
        if name.upper() in s.upper(): stations_match.append(i.upper())
    return stations_match
def top_k_min_temp_stations(stations, K):
    k_min=[]
    for i in stations:
        k_min.append([stations[i]['temp'],i])
    k_min.sort()
    k_minstations=[]
    for j in k_min:
        k_minstations.append(j[1])
    return k_minstations[:K]
def top_k_max_temp_stations(stations, K):
    k_min=[]
    for i in stations:
        k_min.append([stations[i]['temp'],i])
    k_min.sort()
    k_minstations=[]
    for j in k_min:
        k_minstations.append(j[1])
    return k_minstations[:-(K+1):-1]
def peak_stations(stations):
    lat_min=[]
    long_min=[]
    for i in stations:
        lat_min.append([stations[i]['lat'],i])
        long_min.append([stations[i]['long'],i])
    lat_min.sort()
    long_min.sort()
    lat_minstations=[]
    long_minstations=[]
    for j in lat_min: lat_minstations.append(j[1])
    for k in  long_min: long_minstations.append(k[1])

    return [lat_minstations[0],lat_minstations[len(lat_minstations)-1],long_minstations[0],long_minstations[len(long_minstations)-1]]
def k_nearby_stations(stations, main_station, K):
    near=[]
    for i in stations:
        if i !=main_station:
            near.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i])
    near.sort()
    nearstation=[]
    for j in near: nearstation.append(j[1])
    return nearstation[:K]
def average_temp(stations, names):
    sumtemp=0
    for i in names:
        sumtemp+=stations[i]['temp']
    return sumtemp/len(names)


# --------------------------------------------------
# 6330288921 (28.74) 134 (2021-03-29 11:59)

def approx_match(stations, name):
    x = []
    s = name.upper()
    ss = ''
    for j in s :
        if j in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            ss += j
        if j == ' ':
            continue
    for k in stations:
        if ss in k :
            x.append(k)
    return x
def top_k_min_temp_stations(stations, K):
    xmin = []
    xminof = []
    for i in stations :
        xmin.append([stations[i]['temp'],i])
    xmin.sort()
    if xmin != []:
        r = sorted(xmin)
        xmin=r[:K:]
    for q in xmin :
        xminof.append(q[1])
    return xminof
def top_k_max_temp_stations(stations, K):
    xmax = []
    xmaxof = []
    for i in stations :
        xmax.append([stations[i]['temp'],i])
    xmax.sort()
    if xmax != []:
        r=sorted(xmax,reverse=True)
    xmax=r[:K:]
    for q in xmax :
        xmaxof.append(q[1])
    return xmaxof
def peak_stations(stations):
    lati = []
    for k in stations:
        lati.append([stations[k]['lat'], k])
    lati.sort()
    xxa = sorted(lati, reverse=True)
    minlati = lati[0][1]
    maxlati = xxa[0][1]
    longti = []
    for k in stations:
        longti.append([stations[k]['long'], k])
    longti.sort()
    xya = sorted(longti, reverse=True)
    minlongti = longti[0][1]
    maxlongti = xya[0][1]
    return [minlati, maxlati, minlongti, maxlongti]
def k_nearby_stations(stations, main_station, K):
    near = []
    dis = []
    for key in stations:
        if key != main_station:
            lat1 = stations[key]['lat']
            long1 = stations[key]['long']
            lat2 = stations[main_station]['lat']
            long2 = stations[main_station]['long']
            d = distance(lat1, long1, lat2, long2)
            dis.append([d, key])
    dis.sort()
    for i in range(K):
        near.append(dis[0][1])
        dis.remove(dis[0])
    return near
def average_temp(stations, names):
    sum = 0
    for k in stations:
        if k in names:
            sum += stations[k]['temp']
    su = sum/len(names)
    return su



# --------------------------------------------------
# 6330289521 (30) 135 (2021-03-29 13:47)

def approx_match(stations, name):
    name=name.upper()
    name=name.split()
    name="".join(name)
    x=[]
    for c in stations:
        a=c.split()
        a="".join(a)
        if name.upper() in a.upper():
            x+=[c]
    return x
def top_k_min_temp_stations(stations, K):
    x=[]
    for name in stations:
        x+=[[stations[name]["temp"],name]]
    x.sort()
    x=x[:K]
    y=[]
    for i in range(len(x)):
        y+=[x[i][1]]
    return y
def top_k_max_temp_stations(stations, K):
    x=[]
    for name in stations:
        x+=[[-1*float(stations[name]['temp']),name]]
    x.sort()
    x=x[:K:]
    y=[]
    for i in range(len(x)):
        y+=[x[i][1]]
    return y
def peak_stations(stations):
    lat=[]
    long=[]
    for name in stations:
        lat+=[[stations[name]["lat"],name]]
        long+=[[stations[name]["long"],name]]
    lat.sort()
    long.sort()
    if len(lat) !=0 and len(long) != 0:
        return [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    else:
        return []
def k_nearby_stations(stations, main_station, K):
    x=[]
    for name in stations:
        if name != main_station:
            x+=[[stations[name]["lat"],stations[name]["long"],name]]
    ms=[stations[main_station]["lat"],stations[main_station]["long"],name]
    y=[]
    for i in range (len(x)):
        y+=[[distance(float(x[i][0]),float(x[i][1]),float(ms[0]),float(ms[1])),x[i][2]]]
    y.sort()
    z=[]
    for i in range(len(y)):
        z+=[y[i][1]]
    return z[:K]
def average_temp(stations, names):
    a=[]
    for name in names:
        a+=[stations[name]['temp']]
    sum=0
    c=0
    for i in range(len(a)):
        sum+=a[i]
        c+=1
    return (sum/c)

# --------------------------------------------------
# 6330290021 (30) 136 (2021-03-26 20:32)

def approx_match(stations, name):
    s = []
    key = []
    name = ''.join(name.split()).upper()
    key = list(stations.keys())
    for k in key:
        if name in ''.join(k.split()).upper() :
            s.append(k)
    return s
#again
def top_k_min_temp_stations(stations, K):
    s = []
    place = []
    for k,v in stations.items():
        s += [[v['temp'],k]]
    for i in sorted(s)[:K]:
        place.append(i[1])
    return place
def top_k_max_temp_stations(stations, K):
    s = []
    place = []
    for k,v in stations.items():
        s += [[-v['temp'],k]]
    for i in sorted(s)[:K]:
        place.append(i[1])
    return place
def peak_stations(stations):
    la = []
    lo = []
    for k,v in stations.items():
       la += [[v['lat'],k]]
       lo += [[v['long'],k]]
    lo.sort()
    la.sort()
    return[la[0][1],la[-1][1],lo[0][1],lo[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    place = []
    dis = []
    for k,v in stations.items():
        lat2 = v['lat']
        long2 = v['long']
        dis += [[distance(lat1,long1,lat2,long2),k]]
    dis = sorted(dis)[1:K+1]
    for e in dis:
        place.append(e[1])
    return place
def average_temp(stations, names):
    p = 0
    n = 0
    for k,v in stations.items():
        if k in names:
            n += 1
            p += v['temp']
    return p/n


# --------------------------------------------------
# 6330291721 (30) 137 (2021-03-28 22:40)

def approx_match(stations, name):
    allstations = []
    selected_stations = []
    n = name.upper().strip().split()
    x = ''
    for i in n:
        x += i
    for key in stations:
        allstations.append(key)
    for i in allstations:
        if x in i:
            selected_stations.append(i)
    return selected_stations
def top_k_min_temp_stations(stations, K):
    x = []
    topk_mintemp = []
    for e in stations:
        x.append([stations[e]['temp'],e])
    x.sort()
    for i in range(K):
        topk_mintemp.append(x[i][1])
    return topk_mintemp
def top_k_max_temp_stations(stations, K):
    x = []
    topk_maxtemp = []
    for e in stations:
        x.append([stations[e]['temp'],e])
    x.sort(reverse=True)
    for i in range(len(x)-1):
        for i in range(len(x)-1):
            if x[i][0] == x[i+1][0]:
                if x[i][1] > x[i+1][1]:
                    x[i],x[i+1] = x[i+1],x[i]
    for i in range(K):
        topk_maxtemp.append(x[i][1])
    return topk_maxtemp
def peak_stations(stations):
    peak_stations = []
    lat = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
    lat.sort()
    peak_stations.append(lat[0][1])
    peak_stations.append(lat[-1][1])
    long = []
    for e in stations:
        long.append([stations[e]['long'],e])
    long.sort()
    peak_stations.append(long[0][1])
    peak_stations.append(long[-1][1])
    return peak_stations
def k_nearby_stations(stations, main_station, K):
    x = []
    dist = []
    nearby_stations = []
    for e in stations:
        x.append([e,stations[e]['lat'],stations[e]['long']])
    for e in stations:
        dist.append([distance(stations[main_station.upper()]['lat'],stations[main_station.upper()]['long'],stations[e]['lat'],stations[e]['long']),e])
    dist.sort()
    dist = dist[1::]
    n = min(K,len(dist))
    for i in range(n):
        nearby_stations.append(dist[i][1])
    return nearby_stations
def average_temp(stations, names):
    t = 0
    for i in range(len(names)):
        t += stations[names[i]]['temp']
    average_temp = t/len(names)
    return average_temp


# --------------------------------------------------
# 6330292321 (30) 138 (2021-03-28 14:34)

def approx_match(stations, name):
    ans = []
    name = name.upper().replace(' ','')
    for i in stations :
        if name in i.upper().replace(' ',''):
            ans.append(i)
    return ans
def top_k_min_temp_stations(stations, K):
    ans = sorted(stations, key = lambda x: (stations[x]['temp'],x))
    return ans[:K]
def top_k_max_temp_stations(stations, K):
    ans = sorted(stations, key = lambda x: (-stations[x]['temp'],x))
    return ans[:K]
def peak_stations(stations):
    lat_min = sorted(stations, key = lambda x: stations[x]['lat'])[0]
    lat_max = sorted(stations, key = lambda x: stations[x]['lat'], reverse = True)[0]
    long_min = sorted(stations, key = lambda x: stations[x]['long'])[0]
    long_max = sorted(stations, key = lambda x: stations[x]['long'], reverse = True)[0]
    return [lat_min,lat_max,long_min,long_max]
def k_nearby_stations(stations, main_station, K):
    d = {}
    lat,long = stations[main_station]['lat'],stations[main_station]['long']
    for i in stations :
        d[i] = distance(stations[i]['lat'], stations[i]['long'], lat, long)
    return sorted(d, key = lambda x: (d[x],x))[1:K+1]
def average_temp(stations, names):
    t = []
    for i in names:
        t.append(stations[i]['temp'])
    return sum(t)/len(t)
#--------------------------------------------------
# 6330293021 (30) 139 (2021-03-29 02:01)

def approx_match(stations, name):

    name = name.upper()
    Xvid = ''
    Xnxx = []
    for e in name :
        if e == ' ' :
            pass
        else :
            Xvid += e
    for e in stations :
        if Xvid in e :
            Xnxx.append(e)
        else :
            pass
    return Xnxx

#---------------------------------------------------
def top_k_min_temp_stations(stations, K):

    province = []
    final = []
    for name in stations:
        province.append([stations[name]['temp'] ,name])
    province.sort()
    for i in range(K):
        final.append(province[i][1])
    return final

#---------------------------------------------------
def top_k_max_temp_stations(stations, K):

    province = []
    final = []
    for name in stations:
        province.append([-stations[name]['temp'] ,name])
    province.sort()
    for i in range(K):
        final.append(province[i][1])
    return final

#---------------------------------------------------
def peak_stations(stations):

    a = [[stations[key]['lat'],key] for key in stations]
    b = [[stations[key]['long'],key] for key in stations]
    a.sort()
    b.sort()
    return [a[0][1],a[-1][1],b[0][1],b[-1][1]]

#---------------------------------------------------
def k_nearby_stations(stations, main_station, K):

    latlist =[]
    longlist=[]
    dis =[]
    final = []
    main_station = main_station.upper()
    for key in stations:
        if key == main_station:
            continue
        else:
            latlist.append([stations[key]['lat'],key])
            longlist.append([stations[key]['long'],key])
    for i in range(len(latlist)):
        x = distance(latlist[i][0],longlist[i][0],stations[main_station]['lat'],stations[main_station]['long'])
        dis.append([x,latlist[i][1]])
    dis.sort()
    dis = dis[:K]
    for e in dis:
        final.append(e[1])

    return final

#---------------------------------------------------
def average_temp(stations, names):

    Get_High = []
    if names == []:
        return 0
    for e in names:
        if e in stations:
            Get_High.append(stations[e]['temp'])
    if Get_High == []:
        return 0
    return sum(Get_High)/len(Get_High)

# --------------------------------------------------
# 6330294621 (25.5) 140 (2021-03-29 20:48)

def approx_match(stations, name):

    d = ''
    for i in range(len(name)):
        if name[i] != ' ':
           d += name[i].upper()
    qwe = []
    for e in stations:
        f = ''
        for i in range(len(e)):
            if e[i] != ' ':
               f += e[i].upper()
        if f.find(d) != -1:
           qwe.append(e)
    return qwe
def top_k_min_temp_stations(stations, K):

    qwe = []
    for e in stations:
        qwe.append([stations[e]['temp'],e])
    qwe.sort()
    topkmin = []
    d = 0
    while d < K:
        if d <= len(qwe)-1:
           topkmin.append(qwe[d][1])
        d += 1
    return topkmin
def top_k_max_temp_stations(stations, K):

    qwe = []
    for e in stations:
        qwe.append([stations[e]['temp'],e])
    qwe.sort()
    topkmax = []
    d = 0
    while d < K:
        if d <= len(qwe)-1:
            topkmax.append(qwe[len(qwe)+d-K][1])
        d += 1
    return topkmax
def peak_stations(stations):

    latlist = []
    for e in stations:
        latlist.append([stations[e]['lat'],e])
    latlist.sort()
    minlat = latlist[0][1]
    maxlat = latlist[-1][1]

    longlist = []
    for e in stations:
        longlist.append([stations[e]['long'],e])
    longlist.sort()
    minlong = longlist[0][1]
    maxlong = longlist[-1][1]

    return [minlat,maxlat,minlong,maxlong]
def k_nearby_stations(stations, main_station, K):

    lat2 = stations[main_station]['lat']
    long2 = stations[main_station]['long']
    dis_name = []
    for e in stations:
        if e != main_station:
           lat1 = stations[e]['lat']
           long1 = stations[e]['long']
           dis_name.append([distance(lat1, long1, lat2, long2),e])
    dis_name.sort()
    qwe = []
    d = 0
    while d < K:
          if d <= len(stations)-2:
             qwe.append(dis_name[d][1])
          d += 1
    return qwe
def average_temp(stations, names):

    asd = 0
    for e in names:
        asd += stations[e]['temp']
    qwe = asd/3
    return qwe

# --------------------------------------------------
# 6330295221 (28.5) 141 (2021-03-29 16:22)

def approx_match(stations, name):
    bnname = ''
    result = []
    for e in name:
        if e != ' ':
            bnname += e.upper()
    for a in stations:
        b = a
        c = ''
        c += b.replace(' ','').upper()
        if bnname in c:
            result.append(a)
    return result
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    result = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    for e in a:
        b.append(e[1])
    result = b[:K]
    return result
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    result = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    for e in a:
        b.append(e[1])
    result = b[-K:]
    return result
def peak_stations(stations):
    lats = []
    longs = []
    result = []
    for e in stations:
        lats.append([stations[e]['lat'],e])
    for e in stations:
        longs.append([stations[e]['long'],e])
    lats.sort()
    longs.sort()
    result.append(lats[0][1])
    result.append(lats[-1][1])
    result.append(longs[0][1])
    result.append(longs[-1][1])
    return result
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    alldis = []
    result = []
    for e in stations:
        if e != main_station:
            lat2 = stations[e]['lat']
            long2 = stations[e]['long']
            a = distance(lat1, long1, lat2, long2)
            alldis.append([a,e])
    alldis.sort()
    for e in alldis:
        result.append(e[1])
    result = result[:K]
    return result
def average_temp(stations, names):
    sumtemp = 0
    i = 0
    for e in stations:
        if e in names:
            sumtemp += stations[e]['temp']
            i += 1
    result = sumtemp/i
    return result

# --------------------------------------------------
# 6330296921 (30) 142 (2021-03-29 20:57)

def approx_match(stations, name):
    x = name.upper().strip().split()
    x = ''.join(x)
    list_stations = []
    z =[]
    for k in stations:
        Tstations = k.upper().strip().split()
        Tstations = ''.join(Tstations)
        if x in Tstations :
            z.append(k)
    return z
def top_k_min_temp_stations(stations, K):
    list_stations = []
    y = []
    z = []
    for s in stations:
        list_stations.append([s,(stations[s]['temp'])])
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0],list_stations[c][1] = list_stations[c][1],list_stations[c][0]
    list_stations.sort()

    y=list_stations[0:K]
    for i in range(len(y)):
        z.append(y[i][1])
    return z
def top_k_max_temp_stations(stations, K):
    list_stations = []
    y = []
    z = []

    for s in stations:
        list_stations.append([s,-(stations[s]['temp'])])
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0],list_stations[c][1] = list_stations[c][1],list_stations[c][0]
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0] = -list_stations[c][0]

    y=list_stations[0:K]
    for i in range(len(y)):
        z.append(y[i][1])

    return z
def peak_stations(stations):
#minLat=======================================================================
    list_stations = []
    z = []
    for s in stations:
        list_stations.append([s,(stations[s]['lat'])])
    list_stations.sort()
    for c in range(len(list_stations)) :
        list_stations[c][0],list_stations[c][1] = list_stations[c][1],list_stations[c][0]
    list_stations.sort()
    z.append(list_stations[0][1])
#maxLat=============================================================================
    list_stations = []

    for s in stations:
        list_stations.append([s,-(stations[s]['lat'])])
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0],list_stations[c][1] = list_stations[c][1],list_stations[c][0]
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0] = -list_stations[c][0]

    z.append(list_stations[0][1])

#minlong#============================================================
    list_stations = []
    for s in stations:
        list_stations.append([s,(stations[s]['long'])])
    list_stations.sort()
    for c in range(len(list_stations)) :
        list_stations[c][0],list_stations[c][1] = list_stations[c][1],list_stations[c][0]
    list_stations.sort()
    z.append(list_stations[0][1])
#maxLong================================================================================
    list_stations = []

    for s in stations:
        list_stations.append([s,-(stations[s]['long'])])
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0],list_stations[c][1] = list_stations[c][1],list_stations[c][0]
    list_stations.sort()

    for c in range(len(list_stations)) :
        list_stations[c][0] = -list_stations[c][0]

    z.append(list_stations[0][1])
    return z
def k_nearby_stations(stations, main_station, K):
    d = []
    z = []
    y = []
    lat2 = stations[main_station]['lat']
    long2 = stations[main_station]['long']
    for s in stations:
        if s != main_station:
            lat1 = stations[s]['lat']
            long1 = stations[s]['long']
            d.append([s,distance(lat1, long1, lat2, long2)])
    d.sort()
    for c in range(len(d)) :
        d[c][0],d[c][1] = d[c][1],d[c][0]
    d.sort()
    y=d[0:K]
    for i in range(len(y)):
        z.append(y[i][1])
    return z
def average_temp(stations, names):
    d = []
    for s in names:
        d.append(stations[s]['temp'])
    z = sum(d)/len(names)
    return z



# --------------------------------------------------
# 6330298121 (30) 143 (2021-03-29 23:22)

def approx_match(stations, name):
    nn = "".join(name.lower().split())
    sm = []
    for e in stations:
        if nn in e.lower():
            sm.append(e)
    return sm
def top_k_min_temp_stations(stations, K):
    sat = []
    for e in stations:
        sat.append([stations[e]['temp'],e])
    sat.sort()
    s = []
    for e in sat:
        s.append(e[1])
    return s[:K]
def top_k_max_temp_stations(stations, K):
    sat = []
    for e in stations:
        sat.append([-stations[e]['temp'],e])
    sat.sort()
    s = []
    for e in sat:
        s.append(e[1])
    return s[:K]
def peak_stations(stations):
    a = []
    b = []
    for e in stations:
        a.append([stations[e]['lat'],e])
    a.sort()
    for e in stations:
        b.append([stations[e]['long'],e])
    b.sort()
    return [a[0][1],a[-1][1],b[0][1],b[-1][1]]
def k_nearby_stations(stations, main_station, K):
    a = []
    for e in stations:
        if e != main_station:
            a.append([distance(stations[e]['lat'],stations[e]['long'],stations[main_station]['lat'],stations[main_station]['long']),e])
    a.sort()
    b = []
    for e in a:
        b.append(e[1])
    if len(b) >= K:
        return b[:K]
    else:
        return b[:]
def average_temp(stations, names):
    s = 0
    for e in names:
        s += stations[e]['temp']
    s /= len(names)
    return s



# --------------------------------------------------
# 6330299821 (28.74) 144 (2021-03-28 19:49)

def approx_match(stations, name):
    a = ''
    name = name.upper()
    for i in range(len(name)):
        if name[i] in alphabet:
            a += name[i]
    b = []
    for i in stations.keys():
        if a in i:
            b.append(i)
    return b
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for i,j in stations.items():
        temp = j['temp']
        a.append([-temp, i])
    a.sort()
    a = a[::-1]
    if K < len(a):
        min = a[:K]
    for i,j in min:
        b.append(j)
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for i, j in stations.items():
        temp = j['temp']
        a.append([-temp, i])
    a.sort()
    if K < len(a):
        max = a[:K]
    for i, j in max:
        b.append(j)
    return b
def peak_stations(stations):
    a = []
    b = []
    c = []
    for i, j in stations.items():
        name = i
        lat = j['lat']
        lon = j['long']
        a.append([lat, i])
        b.append([lon, i])
    a.sort()
    b.sort()
    c.append(a[0][1])
    c.append(a[-1][1])
    c.append(b[0][1])
    c.append(b[-1][1])
    return c
def k_nearby_stations(stations, main_station, K):
    main_info = stations[main_station]
    main_lat = main_info['lat']
    main_lon = main_info['long']
    a = []
    b = []
    for i, j in stations.items():
        lat = j['lat']
        lon = j['long']
        dis = distance(main_lat,main_lon,lat,lon)
        if dis > 0:
            a.append([dis,i])
    a.sort()
    if K < len(a):
        near = a[0:K]
    for i, j in near:
        b.append(j)
    return b
def average_temp(stations, names):
    sum = 0
    n = 0
    for k in names:
        info = stations[k]
        sum += info['temp']
        n += 1
    avg = round(sum/n, 1)
    return avg

# --------------------------------------------------
# 6330300721 (26) 145 (2021-03-27 15:31)

def approx_match(stations, name):

    name2 = ''
    for e in name.upper() :
        if  'A'<= e <= 'Z' :
            name2 += e
        else :
            pass
    l = []
    for e in stations :
        if name2 in e :
            l.append(e)
    return(l)
def top_k_min_temp_stations(stations, K):

    d = []
    for e in stations :
        d.append([stations[e]['temp'],e])
    d.sort()
    if len(d) > K :
        s = d[:K]
    else :
        s = d
    out = []
    for e in s :
        out.append(e[1])

    return(out)
def top_k_max_temp_stations(stations, K):

    d = []
    for e in stations :
        d.append([-stations[e]['temp'],e])
    d.sort()
    if len(d) > K :
        s = d[:K]
    else :
        s = d
    out = []
    for e in s :
        out.append(e[1])

    return(out)
def peak_stations(stations):

    l = []
    sta_latmin = 'MAE HONG SON'
    latmin = float(stations['MAE HONG SON']['lat'])
    for e in stations :
        if float(stations[e]['lat']) < latmin :
            latmin = float(stations[e]['lat'])
            sta_latmin = e
    l.append(sta_latmin)

    sta_latmax = 'MAE HONG SON'
    latmax = float(stations['MAE HONG SON']['lat'])
    for e in stations :
        if float(stations[e]['lat']) > latmax :
            latmax = float(stations[e]['lat'])
            sta_latmax = e
    l.append(sta_latmax)

    sta_longmin = 'MAE HONG SON'
    longmin = float(stations['MAE HONG SON']['long'])
    for e in stations :
        if float(stations[e]['long']) < longmin :
            longmin = float(stations[e]['long'])
            sta_longmin = e
    l.append(sta_longmin)

    sta_longmax = 'MAE HONG SON'
    longmax = float(stations['MAE HONG SON']['long'])
    for e in stations :
        if float(stations[e]['long']) > longmax :
            longmax = float(stations[e]['long'])
            sta_longmax = e
    l.append(sta_longmax)

    return(l)
def k_nearby_stations(stations, main_station, K):

    l = []
    for e in stations :
        d = distance(stations[e]['lat'],stations[e]['long'],stations[main_station]['lat'],stations[main_station]['long'])
        if d != 0 :
            l.append([d,e])
    l.sort()
    if len(l) > K :
        s = l[:K]
    else :
        s = l
    out = []
    for e in s :
        out.append(e[1])

    return(out)
def average_temp(stations, names):

    s = 0
    for e in names :
        s += float(stations[e]['temp'])
    return(s/len(names))


# --------------------------------------------------
# 6330301321 (30) 146 (2021-03-26 21:48)

def approx_match(stations, name):
  return [e for e in stations if ''.join(name.upper().split()) in ''.join(e.upper().split())]
def top_k_min_temp_stations(stations, K):
  top = sorted(list(stations),key=lambda e :(stations[e]['temp'],e))
  return top[:min(K,len(top))]
def top_k_max_temp_stations(stations, K):
  top = sorted(list(stations),key=lambda e : ((-1)*stations[e]['temp'],e))
  return top[:min(K,len(top))]
def peak_stations(stations):
  return [sorted(list(stations),key=lambda e : stations[e]['lat'])[0], \
          sorted(list(stations),key=lambda e : stations[e]['lat'],reverse=True)[0], \
          sorted(list(stations),key=lambda e : stations[e]['long'])[0], \
          sorted(list(stations),key=lambda e : stations[e]['long'], reverse=True)[0]]
def k_nearby_stations(stations, main_station, K):
  near = sorted(list(stations),key=lambda e : (distance(stations[main_station]['lat'], stations[main_station]['long'], stations[e]['lat'], stations[e]['long']),e))
  return near[min(1,len(near)):min(K+1,len(near))]
def average_temp(stations, names):
  return round(sum([stations[e]['temp'] for e in names])/len(names),1)

# --------------------------------------------------
# 6330302021 (26.82) 147 (2021-03-29 19:45)

def approx_match(stations, name):
    listans = []
    name = name.upper()
    if ' ' in name:
        a,b = name.split()
        for key,value in stations.items():
            if a in key and b in key:
                listans.append(key)
    else:
        a = name
        for key,value in stations.items():
            if a in key :
                listans.append(key)
    return listans
def top_k_min_temp_stations(stations, K):
    lista = []
    lista2 = []
    for key,value in stations.items():
        lista.append([key,stations[key]['temp']])
    lista = sorted(lista, key = lambda lista : (lista[1],lista[0]), reverse=False)
    for a,b in lista[:K]:
        lista2.append(a)
    return lista2
def top_k_max_temp_stations(stations, K):
    lista = []
    lista2 = []
    for key,value in stations.items():
        lista.append([key,stations[key]['temp']])
    lista = sorted(lista, key = lambda lista : (-lista[1],lista[0]), reverse=False)
    for a,b in lista[:K]:
        lista2.append(a)
    return lista2
def peak_stations(stations):
    listlong = []
    listlat = []
    for a,b in stations.items():
        listlong.append([a,stations[a]['long']])
        listlat.append([a,stations[a]['lat']])
    listlong = sorted(listlong, key = lambda listlong : (listlong[1]), reverse=False)
    listlat = sorted(listlat, key = lambda listlat : (listlat[1]), reverse=False)
    return [listlat[0][0], listlat[-1][0] , listlong[0][0], listlong[-1][0]]
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    listans = []
    listans2 = []
    lat2 = stations[main_station]['lat']
    long2 = stations[main_station]['long']
    for key,value in stations.items():
        lat1 = stations[key]['lat']
        long1 = stations[key]['long']
        d = distance(lat1, long1, lat2, long2)
        listans.append([key,float(d)])
    listans = sorted(listans, key = lambda listans : (listans[1],listans[0]), reverse=False)
    for a,b in listans[1:K+1]:
        listans2.append(a)
    return listans2
def average_temp(stations, names):
    listtemp = []
    for n in names:
        listtemp.append(float(stations[n]['temp']))
    avgtemp = sum(listtemp)/len(listtemp)
    return avgtemp



# --------------------------------------------------
# 6330303621 (28.74) 148 (2021-03-29 07:59)

def approx_match(stations, name):
    s = name.upper()
    t=''
    d=[]
    for i in s:
        if i==' ':
            continue
        else :
            t+=i
    for k in stations :
        if t in k :
            d.append(k)
    return d
def top_k_min_temp_stations(stations, K):
    c=[]
    for a,b in stations.items() :
        temp = stations[a]['temp']
        c.append([temp,a])
    d = sorted(c)
    e=[]
    low_temp = []
    for i in range(len(d)) :
        if d[i][0]==d[i-1][0] :
            e.append(d[i][1])
        else :
            if e!=[] :
                e=sorted(e)
                low_temp+=e
                e=[]
                e.append(d[i][1])
            else :
                e.append(d[i][1])
    if e !=[] :
        low_temp+=e
    low_temp = low_temp[:K]
    return low_temp
def top_k_max_temp_stations(stations, K):
    c=[]
    for a,b in stations.items() :
        temp = stations[a]['temp']
        c.append([temp,a])
    d = sorted(c,reverse=True)
    e=[]
    max_temp = []
    for i in range(len(d)) :
        if d[i][0]==d[i-1][0] :
            e.append(d[i][1])
        else :
            if e!=[] :
                e=sorted(e,reverse=True)
                max_temp+=e
                e=[]
                e.append(d[i][1])
            else :
                e.append(d[i][1])
    if e !=[] :
        max_temp+=e
    max_temp = max_temp[:K]
    return max_temp
def peak_stations(stations):
    c=[]
    d=[]
    for a,b in stations.items() :
        c.append([stations[a]['lat'],a])
        d.append([stations[a]['long'],a])
    min_lat = sorted(c)[0][1]
    max_lat = sorted(c,reverse=True)[0][1]
    min_long = sorted(d)[0][1]
    max_long = sorted(d,reverse=True)[0][1]
    return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    n=[]
    for a,b in stations.items() :
        n.append([distance(stations[main_station]['lat'], stations[main_station]['long'], stations[a]['lat'], stations[a]['long']), a])
    c = sorted(n)
    e=[]
    st = []
    for i in range(len(c)) :
        if c[i][0]==c[i-1][0] :
            e.append(c[i][1])
        else :
            if e!=[] :
                e=sorted(e)
                st+=e
                e=[]
                e.append(c[i][1])
            else :
                e.append(c[i][1])
    if e !=[] :
        st+=e
    st = st[1:K+1]
    return st
def average_temp(stations, names):
    n=0
    for a in names :
        n += stations[a]['temp']
    c = n/len(names)
    return c



# --------------------------------------------------
# 6330304221 (30) 149 (2021-03-29 18:26)

def approx_match(stations, name):
    """
    stations: dict, name: string --> list
    1. Get uppercase name of all the station name that have some of the name are the same as "name" in upper letter
    2. for name variable regradless the lowercase, uppercase and space --> convert to upper letter and continue word
    3. append each the original name of 1. to list
    """
    all_stations = []
    name = ''.join(name.upper().split())
    for station in stations:
        if name in ''.join(station.upper().split()):
            all_stations.append(station)
    return all_stations
def top_k_min_temp_stations(stations, K):
    """
    1. Make [[temp, station name], ...] --> sorted ascending(temp ascending and name ascending)
    2. get K list of list and take only station name to min temp station list
    station: {"station": {[lat:'', long:'', temp:'']}}, K: positive int
    return [the minimum temp K stations ascending]
    remark: 1. if station1[temp] = station2[temp]: sort by name
            2. if the number of stations < K: return as there are
    """
    temps_ascending = []
    for station, data in stations.items():
        temps_ascending.append([data['temp'], station])
    temps_ascending.sort()
    return [station for temp, station in temps_ascending[0:K]]
def top_k_max_temp_stations(stations, K):
    """
    station: {"station": {[lat:'', long:'', temp:'']}}, K: positive int
    return [the max temp K stations descending]
    remark: 1. if station1[temp] = station2[temp]: sort by name
            2. if the number of stations < K: return as there are
    """
    temps_ascending = []
    for station, data in stations.items():
        temps_ascending.append([-data['temp'], station])
    temps_ascending.sort()
    return [station for temp, station in temps_ascending[0:K]]
def peak_stations(stations):
    """
    station: {"station": {[lat:'', long:'', temp:'']}}
    process: find the station name that have 1. min latitude, 2. max latitude
                                             3. min longitude 4. max longitude
    return [station1, staion2, ...]
    remark: [min latitude, max latitude, min longitude, max longitude]
    """
    lat, long = [], []
    for station, data in stations.items():
        lat.append([data['lat'], station])
        long.append([data['long'], station])
    lat.sort()
    long.sort()
    return [lat[0][1], lat[-1][1], long[0][1], long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    """ The main station is in the stations --> Don't worry if in case the main station not in the stations"""
    distance_stations = []
    lat_main_station, long_main_station = stations[main_station]['lat'], stations[main_station]['long']
    for station in stations:
        dist = distance(lat_main_station, long_main_station, stations[station]['lat'], stations[station]['long'])
        distance_stations.append([dist, station])
    distance_stations.sort()
    return [station for distance, station in distance_stations[1:K+1]]
def average_temp(stations, names):
    """ The names is the list that contain of the name in station --> Don't worry about the name that not in the station """
    avg_temp_stations = []
    for station in stations:
        if station in names:
            avg_temp_stations.append(stations[station]['temp'])
    return sum(avg_temp_stations)/len(avg_temp_stations)

# --------------------------------------------------
# 6330305921 (30) 150 (2021-03-26 23:03)

def approx_match(stations, name):
    n = ''
    for e in name :
        if e.isalpha and e != ' ':
            n += e
    n = n.upper()
    ans = []
    for e in stations :
        if n in e.upper() :
            ans.append(e.upper())
    return ans
def top_k_min_temp_stations(stations, K):
    s = []
    for e in stations :
        s.append([stations[e]['temp'],e])
    s.sort()
    ans = []
    for i in range(min(K,len(s))) :
        ans.append(s[i][1])
    return ans
def top_k_max_temp_stations(stations, K):
    s = []
    for e in stations :
        s.append([-stations[e]['temp'],e])
    s.sort()
    ans = []
    for i in range(min(K,len(s))) :
        ans.append(s[i][1])
    return ans
def peak_stations(stations):
    ans = []
    s = []
    for e in stations :
        s.append([stations[e]['lat'],e])
    s.sort()
    ans.append(s[0][1])
    ans.append(s[-1][1])
    s = []
    for e in stations :
        s.append([stations[e]['long'],e])
    s.sort()
    ans.append(s[0][1])
    ans.append(s[-1][1])
    return ans
def k_nearby_stations(stations, main_station, K):
    ans = []
    s = []
    for e in stations :
        d = distance(stations[e]['lat'],stations[e]['long'],stations[main_station]['lat'],stations[main_station]['long'])
        s.append([d,e])
    s.sort()
    for i in range(1,min(K+1,len(s))):
        ans.append(s[i][1])
    return ans
def average_temp(stations, names):
    temp = 0.0
    for e in names :
        temp += stations[e]['temp']
    return temp/len(names)


# --------------------------------------------------
# 6330306521 (30) 151 (2021-03-29 23:23)

def approx_match(stations, name):
    n=''
    name=name.upper()
    for i in name :
        if i in 'ABCDEFGHIJLKMNOPQRSTUVWXYZ' :
            n+=i
    s=[]
    for i in stations :
        if n in i :
            s.append(i)
    return s
def top_k_min_temp_stations(stations, K):
    li=[]
    for i in stations :
        li.append([stations[i]['temp'],i])
    li.sort()
    a=[]
    for i in range(K) :
        a.append(li[i][1])
    return a
def top_k_max_temp_stations(stations, K):
    li=[]
    for i in stations :
        li.append([-stations[i]['temp'],i])
    li.sort()
    a=[]
    for i in range(K) :
        a.append(li[i][1])
    return a
def peak_stations(stations):
    la=[]
    lo=[]
    for i in stations :
        la.append([stations[i]['lat'],i])
        lo.append([stations[i]['long'],i])
    la.sort()
    lamin=list(la)
    la.sort(reverse=True)
    lamax=list(la)
    lo.sort()
    lomin=list(lo)
    lo.sort(reverse=True)
    lomax=list(lo)
    latmin=lamin[0][1]
    latmax=lamax[0][1]
    lonmin=lomin[0][1]
    lonmax=lomax[0][1]

    return [latmin,latmax,lonmin,lonmax]
def k_nearby_stations(stations, main_station, K):
    dis=[]
    li=[]
    for i in stations :
        dis.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i])
    dis.sort()
    a=[]
    for i in range(1,K+1) :
        a.append(dis[i][1])
    return a
def average_temp(stations, names):
    sta=[]
    for i in names :
        sta.append(stations[i]['temp'])
    a=0
    for i in sta :
        a+=i
    a=a/len(names)
    return a


# --------------------------------------------------
# 6330308821 (30) 152 (2021-03-29 17:41)

def approx_match(stations, name):
    name = "".join(name.strip().split())
    l_of_stations = []
    for key in stations:
        if name.lower() in "".join(key.split()).lower():
            l_of_stations.append(key)
    return l_of_stations
def top_k_min_temp_stations(stations, K):
    l = [[stations[x]["temp"],x] for x in stations]
    l.sort()
    l2 = [y for x,y in l]
    return l2[:K]
def top_k_max_temp_stations(stations, K):
    l = [[-stations[x]["temp"],x] for x in stations]
    l.sort()
    l2 = [y for x,y in l]
    return l2[:K]
def peak_stations(stations):
    min_lat = [[stations[x]["lat"],x] for x in stations]
    max_lat = [[-stations[x]["lat"],x] for x in stations]
    min_long = [[stations[x]["long"],x] for x in stations]
    max_long = [[-stations[x]["long"],x] for x in stations]

    min_lat.sort()
    max_lat.sort()
    min_long.sort()
    max_long.sort()
    return [min_lat[0][1],max_lat[0][1],min_long[0][1],max_long[0][1]]
def k_nearby_stations(stations, main_station, K):
    l_distance = [[distance(stations[x]["lat"],stations[x]["long"],stations[main_station]["lat"],stations[main_station]["long"]),x] for x in stations]
    l_distance.sort()
    l2 = [y for x,y in l_distance if x != 0]
    return l2[:K]
def average_temp(stations, names):
    l_temp = [stations[x]["temp"] for x in names]
    return sum(l_temp)/len(l_temp)


# --------------------------------------------------
# 6330310021 (30) 153 (2021-03-29 22:19)

def approx_match(stations, name):
    name = name.split()
    name = "".join(name)
    name = name.upper()
    match = []
    for e in stations:
        if name in e:
            match.append(e)
    return match
def top_k_min_temp_stations(stations, K):
    low = []
    for e in stations:
        low.append([stations[e]["temp"], e])
    low.sort()
    lowest_k = []
    for i in range(min(K, len(low))):
        lowest_k.append(low[i][1])
    return lowest_k
def top_k_max_temp_stations(stations, K):
    high = []
    for e in stations:
        high.append([-stations[e]["temp"], e])
    high.sort()
    highest_k = []
    for i in range(min(K, len(high))):
        highest_k.append(high[i][1])
    return highest_k
def peak_stations(stations):
    low_long = []
    low_lat = []
    high_long = []
    high_lat = []
    for e in stations:
        low_long.append([stations[e]["long"], e])
        low_lat.append([stations[e]["lat"], e])
        high_long.append([-stations[e]["long"], e])
        high_lat.append([-stations[e]["lat"], e])
    low_lat.sort()
    low_long.sort()
    high_lat.sort()
    high_long.sort()
    lowest_long = low_long[0][1]
    lowest_lat = low_lat[0][1]
    highest_long = high_long[0][1]
    highest_lat = high_lat[0][1]
    return [lowest_lat, highest_lat, lowest_long, highest_long]
def k_nearby_stations(stations, main_station, K):
    distance_list = []
    for e in stations:
        dist = distance(stations[e]["lat"], stations[e]["long"], stations[main_station]["lat"], stations[main_station]["long"])
        distance_list.append([dist, e])
    distance_list.sort()
    distest = []
    for i in range(1, min(K+1, len(distance_list))):
        distest.append(distance_list[i][1])
    return distest
def average_temp(stations, names):
    total = 0
    for e in names:
        total += stations[e]["temp"]
    return total/len(names)
# --------------------------------------------------
# 6330311621 (30) 154 (2021-03-27 10:50)

def approx_match(stations, name):
    box = ''
    for i in name:
        if 'a'<=i<='z' or 'A'<=i<='Z':
            box += i
        elif not('a'<=i<='z' or 'A'<=i<='Z') and i != ' ':
            return []
    box = box.upper()

    def delete_upper_space(key):
        key_word = ''
        for i in key:
            if 'a'<=i<='z' or 'A'<=i<='Z':
                key_word += i
        return key_word.upper()

    slot = []
    for i in stations:
        if box in delete_upper_space(i):
            slot.append(i)

    return slot
def top_k_min_temp_stations(stations, K):
    num = []
    for i in stations:
        num.append([stations[i]['temp'],i])
    num.sort()
    num = num[:K]

    st_key = []
    for [temp,i] in num:
        st_key.append(i)

    return st_key
def top_k_max_temp_stations(stations, K):
    num = []
    for i in stations:
        num.append([(-1)*stations[i]['temp'],i])
    num.sort()
    f_num = []
    for [temp,i] in num:
        f_num.append([(-1)*temp,i])
    f_num = f_num[:K]

    st_key = []
    for [temp,i] in f_num:
        st_key.append(i)

    return st_key
def peak_stations(stations):
    lat = []
    for i in stations:
        lat.append([stations[i]['lat'],i])
    lat.sort()
    lat_min = lat[0][1]
    lat_max = lat[-1][1]

    long = []
    for i in stations:
        long.append([stations[i]['long'],i])
    long.sort()
    long_min = long[0][1]
    long_max = long[-1][1]

    return [lat_min , lat_max , long_min , long_max]
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']

    dis_st = []
    for i in stations:
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        dis = distance(lat1, long1, lat2, long2)
        dis_st.append([dis,i])
    dis_st.sort()
    dis_st = dis_st[1:K+1]

    st_key = []
    for [dis,i] in dis_st:
        st_key.append(i)

    return st_key
def average_temp(stations, names):
    temp = 0
    for i in names:
        if i.upper() in stations:
            temp += float(stations[i.upper()]['temp'])
    return temp/len(names)

# --------------------------------------------------
# 6330312221 (25.34) 155 (2021-03-27 18:18)

def approx_match(stations, name):
    name = name.upper()
    name = name.split()
    nname = ''
    name2 = ''
    for e in name:
        nname += e
    ans = []
    for i in stations:
        e = i.split()
        for a in e:
            name2 += a
            if nname in name2.upper():
                ans.append(i)
                name2 = ''
    return ans
def top_k_min_temp_stations(stations, K):
    ans = []
    new_dict = {}
    for i in stations:
        new_dict[i] = stations[i]['temp']
    sort_new_dict = sorted(new_dict.items(), key=lambda item: item[1])
    for i in range(len(sort_new_dict)):
        ans.append(sort_new_dict[i][0])
    ans_new2 = ans[:K:]
    return ans_new2
def top_k_max_temp_stations(stations, K):
    ans = []
    new_dict = {}
    for i in stations:
        new_dict[i] = stations[i]['temp']
    sort_new_dict = sorted(new_dict.items(), key=lambda x: x[1], reverse=True)
    for i in range(len(sort_new_dict)):
        ans.append(sort_new_dict[i][0])
    ans_new = ans[:K:]
    return ans_new
def peak_stations(stations):
    ans = []
    ans2 = []
    ans3 = []
    new_dict = {}
    new_dict2 = {}
    for i in stations:
        t = stations[i]
        new_dict[i] = t['lat']
    sort_new_dict = sorted(new_dict.items(), key=lambda x: x[1], reverse=True)
    for i in range(len(sort_new_dict)):
        ans.append(sort_new_dict[i][0])
    ans2.append(ans[0])
    ans2.append(ans[-1])
    for i in stations:
        t = stations[i]
        new_dict2[i] = t['long']
    sort_new_dict2 = sorted(new_dict2.items(), key=lambda x: x[1], reverse=True)
    for i in range(len(sort_new_dict2)):
        ans3.append(sort_new_dict2[i][0])
    ans2.append(ans3[0])
    ans2.append(ans3[-1])
    return ans2
def k_nearby_stations(stations, main_station, K):
    ans = {}
    ans2 = []
    last_ans = []
    for i in stations:
        if i != main_station:
            lat1 = stations[main_station]['lat']
            long1 = stations[main_station]['long']
            lat2 = stations[i]['lat']
            long2 = stations[i]['long']
            ans[i] = distance(lat1,long1,lat2,long2)
    sort_ans = sorted(ans.items(), key=lambda item: item[1])
    for i in sort_ans:
        ans2.append(i[0])
    last_ans = ans2[:K:]
    return last_ans
def average_temp(stations, names):
    avg_temp = 0
    for i in stations:
        if i in names:
            avg_temp += stations[i]['temp']
    avg_temp = avg_temp/len(names)
    return avg_temp

# --------------------------------------------------
# 6330313921 (30) 156 (2021-03-29 20:34)

def approx_match(stations, name):

    name1 = ''
    for n in name.lower() :
        if 'a' <= n <= 'z' :
            name1 += n.upper()
    s = []
    for i in stations.keys() :
        for q in range(len(i)) :
            if i[q:].find(name1) == 0 :
                s.append(i)

    return s
def top_k_min_temp_stations(stations, K):
    s = []
    s1 = []
    n = []
    t = []

    for a in stations.keys() :
        n.append(a)
        t.append(stations[a]['temp'])

    for i in range(len(n)) :
        s1 += [[t[i],n[i]]]
    s1.sort()
    s = s1[0:K]
    mi = []
    for x in range(len(s)) :
        mi.append(s[x][1])

    return mi
def top_k_max_temp_stations(stations, K):
    n = []
    t = []
    n1 = {}
    t1 = {}
    for a in stations.keys() :
        n.append(a)
        t.append(stations[a]['temp'])

    mt = []
    for b in range(len(n)) :
        mt += [[-1*t[b],n[b]]]
    mt.sort()

    maxt1 = []
    for c in range(len(mt)) :
        maxt1 += [[(mt[c][0])*-1,mt[c][1]]]
    maxt1 = maxt1[0:K]

    maxtemp = []
    for nmn in range(len(maxt1)) :
        maxtemp.append(maxt1[nmn][1])

    return maxtemp
def peak_stations(stations):
    lat1 = []
    long1 = []
    n = []
    for p in stations.keys() :
        lat1.append(stations[p]['lat'])
        long1.append(stations[p]['long'])
        n.append(p)
    pk1 = []
    pk2 = []
    for l in range(len(lat1)) :
        pk1 += [[lat1[l],n[l]]]
        pk2 += [[long1[l],n[l]]]
    pk1.sort()
    pk2.sort()
    latmin = pk1[0][1]
    latmax = pk1[-1][1]
    longmin = pk2[0][1]
    longmax = pk2[-1][1]
    peak = [latmin ,latmax ,longmin, longmax]

    return peak
def k_nearby_stations(stations, main_station, K):
    n = []
    for m in stations.keys() :
        n.append(m)
    lat1 = []
    long1 = []
    dis = []
    for e in n :
        lat1.append(stations[e]['lat'])
        long1.append(stations[e]['long'])
    lat2 = stations[main_station]['lat']
    long2 = stations[main_station]['long']

    dis = []
    for a in range(len(lat1)) :
        d = distance(lat1[a] , long1[a] , lat2 , long2 )
        dis.append(d)

    near = []
    for b in range(len(lat1)) :
        near += [[dis[b],n[b]]]
    near.sort()
    nearb = near[1:K+1]

    nearby = []
    for y in range(len(nearb)) :
        nearby.append(nearb[y][1])

    return nearby
def average_temp(stations, names):
    c = 0
    solution = 0
    for a in names :
        solution += stations[a]['temp']
        c += 1
    abar = solution/c

    return abar



# --------------------------------------------------
# 6330314521 (30) 157 (2021-03-28 21:36)

def approx_match(stations, name):
    N = ''
    for n in name.upper():
        if 'A' <= n <= 'Z':
            N += n      #capitalized keyword

    stationlists = []

    for i in stations.keys():
        for c in range(len(i)):
            if i[c:].find(N) == 0:
                stationlists.append(i)
    return stationlists
def top_k_min_temp_stations(stations, K):
    stval = stations.values()
    stkey = stations.keys()

    sttemp = []
    for inform in stval:
        sttemp.append(inform['temp'])

    stname = []
    for e in stkey:
        stname.append(e)

    alist = []
    for q in range(len(stname)):
        alist += [[sttemp[q]] + [stname[q]]]
    alist.sort()

    req = []
    for i in range(len(alist)):
        req.append(alist[i][1])

    return req[:K]
def top_k_max_temp_stations(stations, K):
    stval = stations.values()
    stkey = stations.keys()

    sttemp = []
    for inform in stval:
        sttemp.append(-1 * inform['temp'])

    stname = []
    for e in stkey:
        stname.append(e)

    alist = []
    for q in range(len(stname)):
        alist += [[sttemp[q]] + [stname[q]]]
    alist.sort()

    req = []
    for i in range(len(alist)):
        req.append(alist[i][1])

    return req[:K]
def peak_stations(stations):
    poslat = []
    poslong = []
    for pos in stations.values():
        poslat.append(pos['lat'])
        poslong.append(pos['long'])

    name = []
    for n in stations.keys():
        name.append(n)

    latlist = []
    longlist = []
    for q in range(len(name)):
        latlist += [[poslat[q]] + [name[q]]]
        longlist += [[poslong[q]] + [name[q]]]

    req1 = sorted(latlist)[0][1]
    req2 = sorted(longlist)[0][1]
    req3 = sorted(latlist,reverse = True)[0][1]
    req4 = sorted(longlist,reverse = True)[0][1]

    req = [req1,req3,req2,req4]
    return req
def k_nearby_stations(stations, main_station, K):
    latpos = []
    longpos = []
    for pos in stations.values():
        latpos.append(pos['lat'])
        longpos.append(pos['long'])

    D = []
    for i in range(len(latpos)):
        lat1 = stations[main_station]['lat']
        long1 = stations[main_station]['long']
        lat2 = latpos[i]
        long2 = longpos[i]
        D.append(distance(lat1, long1, lat2, long2))

    name = []
    for n in stations.keys():
        name.append(n)

    D_name = []
    for e in range(len(D)):
        D_name += [[D[e],name[e]]]

    D_name.sort()
    req = []
    for w in range(K):
        req.append(D_name[w+1][1])
    return req
def average_temp(stations, names):
    temp = []
    for t in stations.values():
        temp.append(t['temp'])

    nt = []
    for n in stations.keys():
        nt.append(n)

    ntemp = []
    for i in range(len(temp)):
        ntemp += [[nt[i],temp[i]]]

    tem = []
    for e in range(len(ntemp)):
        if ntemp[e][0] in names:
            tem.append(ntemp[e])


    sum_temp = 0
    for q in range(len(tem)):
        sum_temp += (tem[q][1])

    avtemp = sum_temp / (len(names))
    return avtemp



# --------------------------------------------------
# 6330315121 (30) 158 (2021-03-29 21:22)

def approx_match(stations, name):
    name_1 = ""
    key_st = []
    all_stations = []
    station_matched = []
    for ch in name:
        if ch == " ":
            pass
        else:
            name_1 += ch.upper()
    for key in stations:
        key_st.append(key)
        key_ch = ""
        for ch in key:
            if ch == " ":
                pass
            else:
                key_ch += ch.upper()
        all_stations.append(key_ch)
    for e in all_stations:
        if name_1 in e:
            ind = all_stations.index(e)
            station_matched.append(key_st[ind])
    return station_matched
def top_k_min_temp_stations(stations, K):
    all_temp = []
    min_temp = []
    for key in stations:
        all_temp.append([stations[key]["temp"], key])
    all_temp.sort()
    all_temp_f = all_temp[:K:]
    for i in range(len(all_temp_f)):
        min_temp.append(all_temp_f[i][1])
    return min_temp
def top_k_max_temp_stations(stations, K):
    all_temp = []
    max_temp = []
    for key in stations:
        all_temp.append([-stations[key]["temp"], key])
    all_temp.sort()
    all_temp_f = all_temp[:K:]
    for i in range(len(all_temp_f)):
        max_temp.append(all_temp_f[i][1])
    return max_temp
def peak_stations(stations):
    all_lat = []
    all_long = []
    for key in stations:
        all_lat.append([stations[key]["lat"], key])
    for key in stations:
        all_long.append([stations[key]["long"], key])
    x = [min(all_lat)[1], max(all_lat)[1], min(all_long)[1], max(all_long)[1]]
    return x
def k_nearby_stations(stations, main_station, K):
    all_latlong =[]
    all_d = []
    nearby_st = []
    for key in stations:
        all_latlong.append([stations[key]["lat"], stations[key]["long"] , key])
    for i in range(len(all_latlong)):
        lat2, long2 = all_latlong[i][0],  all_latlong[i][1]
        all_d.append([distance(stations[main_station]["lat"], stations[main_station]["long"], lat2, long2), all_latlong[i][2]])
    all_d.sort()
    distance_f = all_d[1:K+1:]
    for i in range(len(distance_f)):
        nearby_st.append(distance_f[i][1])
    return nearby_st
def average_temp(stations, names):
    all_temp = []
    for key in names:
        all_temp.append(stations[key]["temp"])
    av_temp = sum(all_temp)/len(all_temp)
    return av_temp

# --------------------------------------------------
# 6330316821 (28.74) 159 (2021-03-29 21:43)

def approx_match(stations, name):
    real_name = ''
    stat1 = []
    for x in name:
        if x.upper() in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            real_name += x.upper()
    for e in stations:
        if real_name in e:
            stat1.append(e)
    return stat1
def top_k_min_temp_stations(stations, K):
    temper = []
    temp_fin = []
    for e in stations:
        temper.append([stations[e]['temp'], e])
    temper.sort()
    if len(temper) >= K:
        for i in range(K):
            temp_fin.append(temper[i][1])
    else:
        for i in range(len(temper)):
            temp_fin.append(temper[i][1])
    return temp_fin
def top_k_max_temp_stations(stations, K):
    temper = []
    temp_fin = []
    for e in stations:
        temper.append([stations[e]['temp'], e])
    temper.sort()
    temper = temper[::-1]
    if len(temper) >= K:
        for i in range(K):
            temp_fin.append(temper[i][1])
    else:
        for i in range(len(temper)):
            temp_fin.append(temper[i][1])
    return temp_fin
def peak_stations(stations):
    latitude = []
    longtitude = []
    for e in stations:
        latitude.append([stations[e]['lat'], e])
        longtitude.append([stations[e]['long'], e])
    latitude.sort()
    longtitude.sort()
    peak = [latitude[0][1], latitude[-1][1], longtitude[0][1], longtitude[-1][1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    lat2 = 0
    long = 0
    nearby = []
    nearby_fin = []
    for e in stations:
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        dis = distance(lat1, long1, lat2, long2)
        nearby.append([dis, e])
    nearby.sort()
    nearby = nearby[1:]
    if len(nearby) >= K:
        for i in range(K):
            nearby_fin.append(nearby[i][1])
    else:
        for i in range(len(nearby)):
            nearby_fin.append(nearby[i][1])
    return nearby_fin
def average_temp(stations, names):
    temp = 0
    number = 0
    for e in stations:
        if e in names:
            temp += stations[e]['temp']
            number += 1
    average = temp/number
    return average

# --------------------------------------------------
# 6330317421 (29.6) 160 (2021-03-28 17:13)

def approx_match(stations, name):
    a = []
    for i in stations:
        if ''.join(name.split()).upper() in ''.join(i.split()).upper():
            a += [i]
    return a
def top_k_min_temp_stations(stations, K):
    return ha(stations,'temp',1)[:K]
def top_k_max_temp_stations(stations, K):
    return ha(stations,'temp',-1)[:K]
def peak_stations(stations):
    return(ha(stations,'lat',1)[0],ha(stations,'lat',-1)[0],ha(stations,'long',1)[0],ha(stations,'long',-1)[0])
def k_nearby_stations(stations, main_station, K):
    d = {}
    for i in stations:
        d[i] = distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long'])
    d = sorted(d.items(),key=lambda x:x[1])
    z = []
    for i in d:
        z += [i[0]]
    return z[1:K+1]
def average_temp(stations, names):
    t = 0
    for i in range(len(names)):
        t += stations[names[i]]['temp']
    return t/len(names)
# --------------------------------------------------
def ha(stations,t,r):
    a = {}
    for i in stations:
        a[i] = r*stations[i][t]
    a = sorted(a.items(), key=lambda x:x[1])
    z = []
    for i in a:
        z += [i[0]]
    return z
# 6330318021 (30) 161 (2021-03-29 15:16)

def approx_match(stations, name):
    station_name=[]
    sname=[]
    for k in stations.keys() :
        station_name.append(k)
    station=station_name
    for ch in station :
        ch=ch.split()
        for i in range(len(ch)) :
            ch[i]=ch[i].lower()
            if ch==' ' :
                ch=''
        ch=(''.join(ch)).split()
        sname.append(ch)
    stations_name1=[]
    stations_name2=[]
    for i in range(len(sname)) :
        stations_name1.append([e for e in sname[i][0]])
        stations_name2.append([e for e in sname[i][0]])
    name_list=[]
    for e in name :
        if e!=' ' :
            name_list.append(e.lower())
    approx=[]
    for i in range(len(stations_name1)) :
        search_index=[]
        while True :
            if name_list[0] in stations_name1[i] :
                search_index.append(stations_name1[i].index(name_list[0]))
                stations_name1[i][stations_name1[i].index(name_list[0])]=' '
            else :
                break
        for k in range(len(search_index)) :
            if search_index[k]+len(name_list)<=len(stations_name2[i]) :
                if stations_name2[i][search_index[k]:search_index[k]+len(name_list)]==name_list :
                    approx.append(station_name[i])
    return approx
def top_k_min_temp_stations(stations, K):
 temp_list=[]
 for ch in stations.keys() :
     temp_list.append([stations[ch]['temp'],ch])
 temp_list.sort()
 min_temp_list=[]
 for i in range(K) :
    min_temp_list.append(temp_list[i][1])
 return min_temp_list
def top_k_max_temp_stations(stations, K):
 temp_list=[]
 for ch in stations.keys() :
     temp_list.append([-1*stations[ch]['temp'],ch])
 temp_list.sort()
 max_temp_list=[]
 for i in range(K) :
     max_temp_list.append(temp_list[i][1])
 return max_temp_list
def peak_stations(stations):
 long_list=[]
 lat_list=[]
 for ch in stations.keys() :
     lat_list.append([stations[ch]['lat'],ch])
     long_list.append([stations[ch]['long'],ch])
 lat_list.sort()
 long_list.sort()
 peak_sta=[lat_list[0][1],lat_list[-1][1],long_list[0][1],long_list[-1][1]]
 return peak_sta
def k_nearby_stations(stations, main_station, K):
 stations_coor=[]
 for ch in stations.keys() :
        if ch!=main_station :
         stations_coor.append([stations[ch]['lat'],stations[ch]['long'],ch])
 distance2main_sta=[]
 for e in stations_coor :
     distance2main_sta.append([distance(stations[main_station]['lat'],stations[main_station]['long'],e[0],e[1]),e[2]])
 distance2main_sta.sort()
 distance_2mainsta=[]
 if K>len(distance2main_sta) :
     for i in range(len(distance2main_sta)):
         distance_2mainsta.append(distance2main_sta[i][1])
 else :
     for i in range(K) :
         distance_2mainsta.append(distance2main_sta[i][1])
 return distance_2mainsta
def average_temp(stations, names):
 temp_list=[]
 sum_temp=0
 count=0
 for ch in names :
     sum_temp+=stations[ch]['temp']
     count+=1
 avg_temp=sum_temp/count
 return avg_temp

# --------------------------------------------------
# 6330319721 (30) 162 (2021-03-29 20:19)

def approx_match(stations, name):
    apm = []
    m = name.upper().split()
    m = ''.join(m)
    for i in stations:
        if i.find(m) != -1:
            apm.append(i)
    return apm
def top_k_min_temp_stations(stations, K):
    k = []
    ans = []
    for e in stations:
        t = stations[e]['temp']
        k.append([t,e])
    k.sort()
    a = k[:K]
    for i in a:
        ans.append(i[1])
    return ans
def top_k_max_temp_stations(stations, K):
    k = []
    ans = []
    for e in stations:
        t = stations[e]['temp']
        k.append([-t,e])
    k.sort()
    a = k[:K]
    for i in a:
        ans.append(i[1])
    return ans
def peak_stations(stations):
    lat = []
    long = []
    ans = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
    for e in stations:
        long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    ans += lat[0][1].split(',')+lat[-1][1].split(',')+long[0][1].split(',')+long[-1][1].split(',')
    return ans
def k_nearby_stations(stations, main_station, K):
    near = []
    nearest = []
    lat1 = stations[main_station.upper()]['lat']
    long1 = stations[main_station.upper()]['long']
    for k,v in stations.items():
        lat2 = v['lat']
        long2 = v['long']
        near.append([distance(lat1, long1, lat2, long2) ,k])
    near.sort()
    if len(near) > K+1:
        ans = near[:K+1:1]
    else:
        ans = near
    for a in ans:
        nearest.append(a[1])
    return nearest[1::]
def average_temp(stations, names):
    tt = 0
    for t in names:
        tt += stations[t.upper()]['temp']
    avg = tt/len(names)
    return avg
# --------------------------------------------------
# 6330320221 (30) 163 (2021-03-28 15:43)

def approx_match(stations, name):
    FixName=''
    for ch in name:
        if ch!=' ':
            FixName+=ch.upper()
    station_list=[]
    for place in stations:
        strip_place=''
        for ch in place:
            if ch!=' ':
                strip_place+=ch.upper()
        if FixName in strip_place:
            station_list.append(place)
    return station_list
def top_k_min_temp_stations(stations, K):
    low_temp=[]
    for satani in stations:
        low_temp.append([stations[satani]['temp'],satani])
    low_temp.sort()
    ans=[]
    for e in low_temp[:K]:
        ans.append(e[1])
    return ans
def top_k_max_temp_stations(stations, K):
    max_temp=[]
    for satani in stations:
        max_temp.append([-(stations[satani]['temp']),satani])
    max_temp.sort()
    ans=[]
    for e in max_temp[:K]:
        ans.append(e[1])
    return ans
def peak_stations(stations):
    lat={}
    long={}
    for satani in stations:
        lat[satani]=stations[satani]['lat']
        long[satani]=stations[satani]['long']
    for satani in stations:
        if lat[satani]==min(lat.values()):
            minlat=satani
            break
    for satani in stations:
        if lat[satani]==max(lat.values()):
            maxlat=satani
            break
    for satani in stations:
        if long[satani]==min(long.values()):
            minlong=satani
            break
    for satani in stations:
        if long[satani]==max(long.values()):
            maxlong=satani
            break
    return [minlat,maxlat,minlong,maxlong]
def k_nearby_stations(stations, main_station, K):
    distance_list=[]
    lat_main=stations[main_station.upper()]['lat']
    long_main=stations[main_station.upper()]['long']
    for satani in stations:
        lat_satani=stations[satani]['lat']
        long_satani=stations[satani]['long']
        distance_list.append([distance(lat_satani,long_satani,lat_main,long_main),satani])
    distance_list.sort()
    ans=[]
    for satani_data in distance_list[1:K+1]:
        ans.append(satani_data[1])
    return ans
def average_temp(stations, names):
    temp_data=[]
    for satani in names:
        temp_data.append(stations[satani]['temp'])
    return sum(temp_data)/len(temp_data)

# --------------------------------------------------
# 6330321921 (26.36) 164 (2021-03-29 23:10)

def approx_match(stations, name):
    result = []
    n = removeSpace(name).upper()
    for e in stations:
        ee = removeSpace(e).upper()
        if n in ee:
            result.append(e)
    return result
def top_k_min_temp_stations(stations, K):
    temp = []
    for city in stations:
        temp.append(stations[city]['temp'])
    temp.sort()
    cityy = []
    for i in range(K):
        for city in stations:
            if stations[city]['temp'] == temp[i]:
                cityy.append(city)
    return cityy
def top_k_max_temp_stations(stations, K):
    temp = []
    for city in stations:
        temp.append(stations[city]['temp'])
    temp.sort()
    temp_rev = temp[::-1]
    cityy = []
    for i in range(K):
        for city in stations:
            if stations[city]['temp'] == temp_rev[i]:
                cityy.append(city)
    return cityy
def peak_stations(stations):
    lat = []
    long = []
    for city in stations:
        lat.append(stations[city]['lat'])
        long.append(stations[city]['long'])
    max_lat = max(lat) ; min_lat = min(lat)
    max_long = max(long) ; min_long = min(long)
    cityy = []
    for city in stations:
        if stations[city]['lat'] == max_lat:
            cityy.append(city)
        elif stations[city]['lat'] == min_lat:
            cityy.append(city)
        elif stations[city]['long'] == max_long:
            cityy.append(city)
        elif stations[city]['long'] == min_long:
            cityy.append(city)
    return cityy
def k_nearby_stations(stations, main_station, K):
    dis = []
    dist = { }
    for city in stations:
        dd = distance(stations[city]['lat'], stations[city]['long'], stations[main_station]['lat'], stations[main_station]['long'])
        dis.append(dd)
        dist[city] = dd
    dis.sort()
    dis = dis[1:]
    cityy = []
    for i in range(K):
        for city in dist:
            if dist[city] == dis[i]:
                cityy.append(city)
    return cityy
def average_temp(stations, names):
    total = 0
    c = 0
    for city in names:
        total += stations[city]['temp']
        c += 1
    return total/c





# --------------------------------------------------
def removeSpace(s):
    result = ''
    for e in s:
        if e != ' ':
            result += e
    return result
# 6330322521 (30) 165 (2021-03-29 13:39)

def approx_match(stations, name):
    n=''
    for e in name:
        if not e==' ':n+=e
    n=n.upper()

    o=[]
    for key in stations:
        k=''
        for e in key:
            if e!=' ':k+=e
        if n in k:
            o.append(key)
    return o
def top_k_min_temp_stations(stations, K):
    k = []
    for e in stations:
        t = stations[e]['temp']
        k.append([t,e])
    k.sort()
    m = k[:K]
    v = []
    for e in m:
        v.append(e[1])
    return v
def top_k_max_temp_stations(stations, K):
    a=[]
    for key in stations:
        a.append([-stations[key]['temp'],key])
    a.sort()
    b=[]
    for i in range(K):
        b.append(a[i][1])
    return b
def peak_stations(stations):
    k = []
    j = []
    for e in stations:
        t = stations[e]['lat']
        k.append([t,e])
        j.append([-t,e])
    j.sort()
    k.sort()
    v = []
    v.append(k[0][1])
    v.append(j[0][1])
    n = []
    m = []
    for e in stations:
        t = stations[e]['long']
        n.append([t,e])
        m.append([-t,e])
    n.sort()
    m.sort()
    v.append(n[0][1])
    v.append(m[0][1])
    return v
def k_nearby_stations(stations, main_station, K):
    a=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    b=[]
    for key in stations:
        lat2=stations[key]['lat']
        long2=stations[key]['long']
        a.append([distance(lat1, long1, lat2, long2),key])
    a.sort()
    if K+1<len(a):
        for i in range(1,K+1):
            b.append(a[i][1])
    else:
        for e in a:
            b.append(e)
    return b
def average_temp(stations, names):
    a=0
    c=0
    for e in names:
        a+=stations[e]['temp']
        c+=1
    b=a/c
    return b



# --------------------------------------------------
# 6330323121 (30) 166 (2021-03-29 18:32)

def approx_match(stations, name):
    n=''
    name2=name.upper()
    a='abcdefghijklmnopqrstuvwxyz'

    for k in name2 :
        if k in a.upper():
            n+=k
    a=[]
    for i in stations:
        if n in i:
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    l=[]
    for i in stations:
        l.append([float(stations[i]['temp']),i])
    l.sort()
    km=[]
    if len(l)>=K:
        for i in range(K):
            km.append(l[i][1])
    else:
        for i in range(len(l)):
            km.append(l[i][1])



    return km
def top_k_max_temp_stations(stations, K):
    l=[]
    for i in stations:
        l.append([float(stations[i]['temp'])*(-1),i])
    l.sort()

    km=[]
    if len(l)>=K:
        for i in range(K):
            km.append(l[i][1])
    else:
        for i in range(len(l)):
            km.append(l[i][1])



    return km
def peak_stations(stations):
    lat=[]
    for i in stations:
        lat.append([float(stations[i]['lat']),i])
    lat.sort()
    long=[]
    for i in stations:
        long.append([float(stations[i]['long']),i])
    long.sort()
    return [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat_m=stations[main_station]['lat']
    long_m=stations[main_station]['long']
    k_near=[]
    for i in stations:
        if i!= main_station:
            k_near.append([distance(lat_m, long_m, stations[i]['lat'], stations[i]['long']),i])
    k_near.sort()
    show=[]
    if  len(k_near)>=K:
        for i in range(K):

            show.append(k_near[i][1])
    else:
        for i in range(len(k_near)):
            show.append(k_near[i][1])
    return show
def average_temp(stations, names):
    sum=0.0
    for i in names:
        sum+=stations[i]['temp']
    return sum/len(names)




# --------------------------------------------------
# 6330324821 (30) 167 (2021-03-27 00:58)

def approx_match(stations, name):
    newname = delete(name)
    Station_have=[]
    for s in stations.keys():
        if newname in delete(s):
            Station_have.append(s)
    return Station_have
def top_k_min_temp_stations(stations, K):
    K_station=[]
    for k,v in stations.items():
        K_station.append([v['temp'],k])
    K_station.sort()
    if len(K_station)>K:
        Ans=K_station[:K:1]
    else:
        Ans=K_station
    Min=[]
    for c in Ans:
        Min.append(c[1])
    return Min
def top_k_max_temp_stations(stations, K):
    K_station=[]
    for k,v in stations.items():
        K_station.append([-v['temp'],k])
    K_station.sort()
    if len(K_station)>K:
        Ans=K_station[:K:1]
    else:
        Ans=K_station
    Max=[]
    for c in Ans:
        Max.append(c[1])
    return Max
def peak_stations(stations):
    Pointlat=[]
    Pointlong=[]
    for k,v in stations.items():
        Pointlat.append([v['lat'],k])
        Pointlong.append([v['long'],k])
    Answer=[]
    Answer.append(sorted(Pointlat)[0][1])
    Answer.append(sorted(Pointlat)[-1][1])
    Answer.append(sorted(Pointlong)[0][1])
    Answer.append(sorted(Pointlong)[-1][1])
    return Answer
def average_temp(stations, names):
    total=0
    for c in names:
        total+=stations[c.upper()]['temp']
    avg=total/len(names)
    return avg
# --------------------------------------------------
def delete(name):
    newname = ''
    for n in name.upper():
        if n==' ':
            pass
        else:
            newname+=n
    return newname
# 6330325421 (30) 168 (2021-03-29 23:59)

def approx_match(stations, name):
    b=[]
    new_sta={}
    for i in stations:
        a=''.join(i.upper().split())
        new_sta[i]=a
    name=''.join(name.upper().split())
    for i in new_sta:
        if name in new_sta[i]:
            b.append(i)
    return b
def top_k_min_temp_stations(stations, K):
    a=[]
    d=[]
    station_temp={}
    for i in stations:
        station_temp[i]=stations[i]['temp']
    stations=station_temp
    for i in stations:
        a.append([stations[i],i])
    a.sort()
    for i in a:
        d.append(i[1])
    return d[0:K]
def top_k_max_temp_stations(stations, K):
    a=[]
    d=[]
    station_temp={}
    for i in stations:
        station_temp[i]=stations[i]['temp']
    stations=station_temp
    for i in stations:
        a.append([-stations[i],i])
    a.sort()
    for i in a:
        d.append(i[1])
    return d[0:K]
def peak_stations(stations):
    a=[]
    b=[]
    for i in stations:
        a.append([stations[i]['lat'],i])
        b.append([stations[i]['long'],i])
    mila=min(a)[1]
    milo=min(b)[1]
    mala=max(a)[1]
    malo=max(b)[1]
    return [mila,mala,milo,malo]
def k_nearby_stations(stations, main_station, K):
    all_stations=[]
    for i in stations:
        all_stations.append(i)
    nearest={}
    main_target=stations[main_station]['lat'],stations[main_station]['long']
    for s in all_stations:
        nearest[s]=distance(stations[main_station]['lat'],stations[main_station]['long'],stations[s]['lat'],stations[s]['long'])
    a=[]
    d=[]
    for i in nearest:
        a.append([nearest[i],i])
    a.sort()
    for i in a:
        d.append(i[1])
    return d[1:K+1]
def average_temp(stations, names):
    station_temp={}
    for i in stations:
        station_temp[i]=stations[i]['temp']
    stations=station_temp
    sig=0
    amount=len(names)
    new={}
    for i in names:
        sig+=float(stations[i])
    return (sig/amount)
# --------------------------------------------------
# 6330326021 (28.32) 169 (2021-03-27 23:46)

def approx_match(stations, name):
    name = name.upper().split()
    count = len(name)
    result = []
    for s in stations.keys():
        c = 0
        for w in name:
            l = len(w)
            for i in range(len(s) - l + 1):
                if w == s[i:i+l]:
                    c += 1
                    break
        if c == count:
            result.append(s)
    return result
def top_k_min_temp_stations(stations, K):
    temp = sorted([p["temp"] for p in stations.values()])[:K]
    return stations_for_temp(stations,temp)[:K]
def top_k_max_temp_stations(stations, K):
    temp = sorted([p["temp"] for p in stations.values()])[::-1][:K]
    return stations_for_temp(stations,temp)[:K]
def peak_stations(stations):
    min_lat = min([p["lat"] for p in stations.values()])
    max_lat = max([p["lat"] for p in stations.values()])
    min_long = min([p["long"] for p in stations.values()])
    max_long = max([p["long"] for p in stations.values()])
    result = []
    for m in [min_lat, max_lat]:
        for s in stations:
            if stations[s]["lat"] == m:
                result.append(s)
                break
    for m in [min_long, max_long]:
        for s in stations:
            if stations[s]["long"] == m:
                result.append(s)
                break
    return result
def k_nearby_stations(stations, main_station, K):
    distances = []
    lat1 = stations[main_station]["lat"]
    long1 = stations[main_station]["long"]
    for p in stations.values():
        lat2 = p["lat"]
        long2 = p["long"]
        distances.append(distance(lat1, long1, lat2, long2))
    distances = sorted(distances)[1:K+1]
    result = []
    for d in distances:
        for s in stations.keys():
            lat2 = stations[s]["lat"]
            long2 = stations[s]["long"]
            if distance(lat1, long1, lat2, long2) == d:
                result.append(s)
    return result[:K]
def average_temp(stations, names):
    total_temp = 0
    for s in names:
        total_temp += stations[s]["temp"]
    return total_temp / len(names)

# --------------------------------------------------
def stations_for_temp(stations,temp):
    result = []
    for t in temp:
        for s in sorted(stations.keys()):
            if stations[s]["temp"] == t:
                result.append(s)
    return result
# 6330327721 (30) 170 (2021-03-29 16:46)

def approx_match(stations, name):
    ch='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    name=name.upper()
    n=''
    for i in name:
        if i in ch:
            n+=i
    ans=[]
    for i in stations:
        x=''
        for l in i:
            if l in ch:
                x+=l
        if n in i:
            ans.append(i)
    return ans
def top_k_min_temp_stations(stations, K):
    x=[]
    for i in stations:
        x.append([stations[i]['temp'],i])
    x.sort()
    ans=[]
    if K<len(x):
        for i in range(K):
            ans.append(x[i][1])
    else:
        for i in range(len(x)):
            ans.append(x[i][1])
    return ans
def top_k_max_temp_stations(stations, K):
    x=[]
    for i in stations:
        x.append([-(stations[i]['temp']),i])
    x.sort()
    ans=[]
    if K<len(x):
        for i in range(K):
            ans.append(x[i][1])
    else:
        for i in range(len(x)):
            ans.append(x[i][1])
    return ans
def peak_stations(stations):
    ltm=cl(stations,'lat')[0][1]
    ltM=cl(stations,'lat')[-1][1]
    lgm=cl(stations,'long')[0][1]
    lgM=cl(stations,'long')[-1][1]
    ans=[ltm,ltM,lgm,lgM]
    return ans
def k_nearby_stations(stations, main_station, K):
    dis=[]
    for i in stations:
        x=distance(stations[main_station]['lat'], stations[main_station]['long'], stations[i]['lat'], stations[i]['long'])
        dis.append([x,i])
    dis.sort()
    ans=[]
    if K<len(dis):
        for i in range(1,K+1):
            ans.append(dis[i][1])
    else:
        for i in range(1,len(x)):
            ans.append(dis[i][1])
    return ans
def average_temp(stations, names):
    x=0
    for i in names:
        x+=stations[i]['temp']
    x=x/len(names)
    return x



# --------------------------------------------------
def cl(stations,t):
    x=[]
    for i in stations:
        x.append([stations[i][t],i])
    x.sort()
    return x
# 6330328321 (30) 171 (2021-03-27 15:49)

def approx_match(stations, name):
    name=name.split()
    name=''.join(name)
    name=name.upper()
    l=list()
    for key in stations.keys():
        tem=key.split()
        tem=''.join(tem)
        if name in tem:
            l.append(key)
    return l
def top_k_min_temp_stations(stations, K):
    tem=list()
    for key,value in stations.items():
        tem.append([value['temp'],key])
    tem.sort()
    l=list()
    for i in range(K):
        if i<len(tem):
            l.append(tem[i][1])
    return l
def top_k_max_temp_stations(stations, K):
    tem=list()
    for key,value in stations.items():
        tem.append([-value['temp'],key])
    tem.sort()
    l=list()
    for i in range(K):
        if i<len(tem):
            l.append(tem[i][1])
    return l
def peak_stations(stations):
    lat=list()
    for key,value in stations.items():
        lat.append([value['lat'],key])
    lat.sort()
    long=list()
    for key,value in stations.items():
        long.append([value['long'],key])
    long.sort()
    return [lat[0][1],lat[len(lat)-1][1],long[0][1],long[len(long)-1][1]]
def k_nearby_stations(stations, main_station, K):
    main_station=main_station.upper()
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    tem=list()
    for key,value in stations.items():
        dist = distance(lat1,long1,value['lat'],value['long'])
        if dist!=0:
            tem.append([dist,key])
    tem.sort()
    l=list()
    for i in range(K):
        if i<len(tem):
            l.append(tem[i][1])
    return l
def average_temp(stations, names):
    avg=0
    for i in range(len(names)):
        avg+=stations[names[i]]['temp']
    return avg/len(names)
# --------------------------------------------------
# 6330329021 (30) 172 (2021-03-28 14:22)

def approx_match(stations, name):
    name = ''.join([ e for e in name.strip().upper() if e != ' '])
    station_list = []
    for s in stations:
        if name in ''.join([e for e in s if e!= ' ']).upper():
            station_list.append(s)
    return station_list
def top_k_min_temp_stations(stations, K):
    min_to_max_temp = [[stations[s]['temp'], s] for s in stations]
    min_to_max_temp.sort()
    return [s for t,s in min_to_max_temp][:K]
def top_k_max_temp_stations(stations, K):
    max_to_min_temp = [[-stations[s]['temp'], s] for s in stations]
    max_to_min_temp.sort()
    return [s for t,s in max_to_min_temp][:K]
def peak_stations(stations):
    lat_list = [[stations[s]['lat'],s] for s in stations]
    lat_list.sort()
    long_list = [[stations[s]['long'],s] for s in stations]
    long_list.sort()
    return [lat_list[0][1],lat_list[-1][1],long_list[0][1],long_list[-1][1]]
def k_nearby_stations(stations, main_station, K):
    distance_list = [[distance(stations[s]['lat'],stations[s]['long'],stations[main_station]['lat'],stations[main_station]['long']),s] for s in stations if s != main_station]
    distance_list.sort()
    return [s for dis,s in distance_list][:K]
def average_temp(stations, names):
    all_temp = [stations[s]['temp'] for s in names]
    return sum(all_temp)/len(all_temp)
# --------------------------------------------------
# 6330330521 (28.74) 173 (2021-03-29 21:12)

def approx_match(stations, name):
    newname = ''
    approx_list = []
    name = name.upper()
    for i in name:
        if i != ' ':
            newname += i
    for key in stations:
        allname = key.split()
        allname = ''.join(allname)
        if newname in allname:
            approx_list.append(key)
    return approx_list
def top_k_min_temp_stations(stations, K):
    list_temp = []
    list_k_min = []
    for key in stations:
        n = list()
        n.append(stations[key]['temp'])
        n.append(key)
        list_temp.append(n)
    list_temp.sort()
    for i in range (K):
        list_k_min.append(list_temp[i][1])
    return list_k_min
def top_k_max_temp_stations(stations, K):
    list_temp = []
    list_k_max = []
    for key in stations:
        n = list()
        n.append(stations[key]['temp'])
        n.append(key)
        list_temp.append(n)
    list_temp.sort()
    for i in range (K):
        list_k_max.append(list_temp[-i-1][1])
    return list_k_max
def peak_stations(stations):
    peak_list = []
    list_lat = []
    list_long = []
    for key in stations:
        n = list()
        n.append(stations[key]['lat'])
        n.append(key)
        list_lat.append(n)
    list_lat.sort()
    peak_list.append(list_lat[0][1])
    peak_list.append(list_lat[-1][1])
    for key in stations:
        n = list()
        n.append(stations[key]['long'])
        n.append(key)
        list_long.append(n)
    list_long.sort()
    peak_list.append(list_long[0][1])
    peak_list.append(list_long[-1][1])
    return peak_list
def k_nearby_stations(stations, main_station, K):
    distance_all = []
    distance_k_min = []
    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    for key,value in stations.items():
        n = list()
        long = value['long']
        lat = value['lat']
        distances = distance(lat_main,long_main,lat,long)
        n.append(distances)
        n.append(key)
        distance_all.append(n)
    distance_all.sort()
    for i in range (K):
        distance_k_min.append(distance_all[i+1][1])
    return distance_k_min
def average_temp(stations, names):
    average = 0
    sum_temp = 0
    for i in range (len(names)):
        sum_temp += stations[names[i]]['temp']
    average = sum_temp/(len(names))
    return average



# --------------------------------------------------
# 6330331121 (30) 174 (2021-03-29 17:40)

def approx_match(stations, name):
    nameup = name.upper()
    nameee = ""
    x = []

    for i in nameup:
        if not i == " ":
            nameee += i
    if nameee == "":
        return []

    for e in stations:
        up = ""
        for j in e:
            if not j == " ":
                up += j.upper()
        if nameee in up:
            x.append(str(e))


    return x
def top_k_min_temp_stations(stations, K):
    z = []
    s = []
    s1 = []
    for i in stations:
        s.append([stations[i]["temp"], i])
        s.sort()

    s1 = s[:K]
    for h in range(len(s1)):
        z.append(s1[h][1])

    return z
def top_k_max_temp_stations(stations, K):
    z = []
    s = []
    s1 = []
    for i in stations:
        s.append([-stations[i]["temp"], i])
        s.sort()

    s1 = s[:K]
    for h in range(len(s1)):
        z.append(s1[h][1])

    return z
def peak_stations(stations):
    lamin = []
    lamax = []
    lomin = []
    lomax = []
    for k in stations:
        lamin.append([stations[k]["lat"], k])
        lamax.append([-stations[k]["lat"], k])
        lomin.append([stations[k]["long"], k])
        lomax.append([-stations[k]["long"], k])
        lamin.sort()
        lamax.sort()
        lomin.sort()
        lomax.sort()

    lamin1 = lamin[0][1]
    lamax1 = lamax[0][1]
    lomin1 = lomin[0][1]
    lomax1 = lomax[0][1]

    return [lamin1, lamax1, lomin1, lomax1]
def k_nearby_stations(stations, main_station, K):
    x = []
    y = []
    z = []
    for i in stations:
        dis = distance(stations[main_station]["lat"], stations[main_station]["long"], stations[i]["lat"], stations[i]["long"])
        x.append([dis, i])
        x.sort()
        y = x[:K+1]

    y = y[1:]
    for e in range(len(y)):
        z.append(y[e][1])

    return z
def average_temp(stations, names):
    aver = 0
    for a in names:
        aver += stations[a]["temp"]
        aver1 = aver/len(names)

    return aver1

# --------------------------------------------------
# 6330332821 (30) 175 (2021-03-28 21:48)

def approx_match(stations, name):
    name = name.replace(" ","");
    names = []
    for station in stations:
        if(station.find(name.upper())!=-1):
            names.append(station)

    return names
def top_k_min_temp_stations(stations, K):
    stationsList = []
    stationsNameList = []
    lenth = K
    for station in stations:
        stations[station]['name'] = station;
        stationsList.append(stations[station]);
    stationsList.sort(key=lambda x: x['name'],reverse=False)
    stationsList.sort(key=lambda x: x['temp'],reverse=False)
    if lenth > len(stationsList):
        lenth=len(stationsList)
    for key in range(lenth):
        stationsNameList.append(stationsList[key]['name'])

    return stationsNameList
def top_k_max_temp_stations(stations, K):
    stationsList = []
    stationsNameList = []
    lenth = K
    for station in stations:
        stations[station]['name'] = station
        stationsList.append(stations[station])
    stationsList.sort(key=lambda x: x['name'],reverse=False)
    stationsList.sort(key=lambda x: x['temp'],reverse=True)
    if lenth > len(stationsList):
        lenth=len(stationsList)
    for key in range(lenth):
        stationsNameList.append(stationsList[key]['name'])

    return stationsNameList
def peak_stations(stations):
    stationsLatMinList = []
    stationsLatMaxList = []
    stationsLongMinList = []
    stationsLongMaxList = []
    stationsNameList = []
    for station in stations:
        stations[station]['name'] = station
        stationsLatMinList.append(stations[station])
        stationsLatMaxList.append(stations[station])
        stationsLongMinList.append(stations[station])
        stationsLongMaxList.append(stations[station])

    stationsLatMinList.sort(key=lambda x: x['lat'],reverse=False)
    stationsLatMaxList.sort(key=lambda x: x['lat'],reverse=True)
    stationsLongMinList.sort(key=lambda x: x['long'],reverse=False)
    stationsLongMaxList.sort(key=lambda x: x['long'],reverse=True)

    stationsNameList.append(stationsLatMinList[0]['name'])
    stationsNameList.append(stationsLatMaxList[0]['name'])
    stationsNameList.append(stationsLongMinList[0]['name'])
    stationsNameList.append(stationsLongMaxList[0]['name'])
    return stationsNameList
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    mainStationObj = stations[main_station]
    stationsList = []
    stationsDistanceList = []
    for station in stations:
        stations[station]['distance'] = distance(mainStationObj['lat'],mainStationObj['long'],stations[station]['lat'],stations[station]['long'])
        stations[station]['name'] = station

        stationsList.append(stations[station])

    stationsList.sort(key=lambda x: x['distance'],reverse=False)
    for key in range(K):
        stationsDistanceList.append(stationsList[key+1]['name'])
    return stationsDistanceList
def average_temp(stations, names):
    sumTemp = 0;
    stationList = {}
    for station in stations:
        stationList[station] = stations[station]
    for name in names:
        sumTemp += stationList[name]['temp']
    return sumTemp/len(names)
# --------------------------------------------------
# 6330333421 (30) 176 (2021-03-29 17:44)

def approx_match(stations, name):
    result = []
    for key in stations:
        if name.upper().replace(' ','') in key.upper().replace(' ', ''):
            result.append(key)
    return result
def top_k_min_temp_stations(stations, K):
    min_temp = sorted(list(stations.items()), key=lambda x: x[1]['temp'], reverse=False)[:K]
    min_temp = [(station[1]['temp'],station[0]) for station in min_temp]
    min_temp = sorted(min_temp, key=lambda x: x[1])
    min_temp = sorted(min_temp, key=lambda x: x[0], reverse=False)
    return [station[1] for station in min_temp]
def top_k_max_temp_stations(stations, K):
    max_temp = sorted(list(stations.items()), key=lambda x: x[1]['temp'], reverse=True)[:K]
    max_temp = [(station[1]['temp'],station[0]) for station in max_temp]
    max_temp = sorted(max_temp, key=lambda x: x[1])
    max_temp = sorted(max_temp, key=lambda x: x[0], reverse=True)
    return [station[1] for station in max_temp]
def peak_stations(stations):

    min_lat = sorted(list(stations.items()), key=lambda x: x[1]['lat'], reverse=False)[0][0]
    max_lat = sorted(list(stations.items()), key=lambda x: x[1]['lat'], reverse=True)[0][0]
    min_long = sorted(list(stations.items()), key=lambda x: x[1]['long'], reverse=False)[0][0]
    max_long = sorted(list(stations.items()), key=lambda x: x[1]['long'], reverse=True)[0][0]
    return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    main_station_dict = stations[main_station]
    d_stations = [[s[0],distance(main_station_dict['lat'], main_station_dict['long'],s[1]['lat'], s[1]['long'])] for s in stations.items()]
    sorted_stations = sorted(d_stations, key=lambda s: s[0])
    sorted_stations = sorted(d_stations, key=lambda s: s[1])
    result = []
    for station in sorted_stations:
        if station[0] != main_station:
            print(station[0], main_station)
            result.append(station[0])
    return result[:K]
def average_temp(stations, names):
    sum_temp = 0.0
    for name in names:
        sum_temp += stations[name]['temp']
    return sum_temp/len(names)


# --------------------------------------------------
# 6330334021 (30) 177 (2021-03-27 23:12)

def approx_match(stations, name):
    name = name.upper()
    n = ''
    mtch = []
    stationss = {}
    for x in stations:
        stationss[x.upper()]  = x
    for ch in name:
        if ch != ' ':
            n += ch
    for st in stationss:
        if n in st:
            mtch.append(stationss[st])
    return mtch
def top_k_min_temp_stations(stations, K):
    s = []
    minn = []
    for i in stations:
       s.append([[stations[i]['temp']], i])
    s.sort()
    for ss in range(K):
        minn.append(s[ss][1])
    return minn
def top_k_max_temp_stations(stations, K):
    v = []
    maxx = []
    for ii in stations:
       v.append([[-1*stations[ii]['temp']], ii])
    v.sort()
    for vv in range(K):
        maxx.append(v[vv][1])
    return maxx
def peak_stations(stations):
    lat = []
    long = []
    for l in stations:
       lat.append([[stations[l]['lat']], l])
    lat.sort()
    for ll in stations:
       long.append([[stations[ll]['long']], ll])
    long.sort()
    return [lat[0][1], lat[-1][1], long[0][1], long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    dis = []
    near = []
    for n2station in stations:
        if n2station != main_station:
            lat2 = stations[n2station]['lat']
            long2 = stations[n2station]['long']
            dis.append([distance(lat1, long1, lat2, long2), n2station])
    dis.sort()
    for num in range(K):
        near.append(dis[num][1])
    return near
def average_temp(stations, names):
    summ = 0
    for stns in names:
       summ += stations[stns]['temp']
    return (summ/len(names))


# --------------------------------------------------
# 6330335721 (30) 178 (2021-03-25 18:57)

def approx_match(stations, name):
    name2=""
    li = []
    for i in name:
        if i.isalpha():
            name2+=i.lower()
    for i in stations:
        if name2 in i.lower():
            li.append(i)
    return li
def top_k_min_temp_stations(stations, K):
    tem = []
    tem2= []
    for i in stations:
        tem.append([stations[i]["temp"],i])
    tem.sort()
    for i in tem:
        tem2.append(i[1])
    if K > len(tem2):
        return tem2
    else:
        return tem2[0:K]
def top_k_max_temp_stations(stations, K):
    tem = []
    tem2= []
    for i in stations:
        tem.append([stations[i]["temp"],i])
    tem.sort(reverse=True)
    for i in range(len(tem)):
        for j in range(len(tem)-1):
            if tem[j][1] > tem[j+1][1] and tem[j][0] == tem[j+1][0]:
                tem[j][1], tem[j+1][1] = tem[j+1][1], tem[j][1]
    for i in tem:
        tem2.append(i[1])
    if K > len(tem2):
        return tem2
    else:
        return tem2[0:K]
def peak_stations(stations):
    lat22 = []
    long22 = []
    for i in stations:
        lat22.append([stations[i]["lat"],i])
        long22.append([stations[i]["long"],i])
    lat22.sort();long22.sort()
    return [lat22[0][1],lat22[-1][1],long22[0][1],long22[-1][1]]
def k_nearby_stations(stations, main_station, K):
    dis=[]
    ddd=[]
    ndis=[]
    latlong = []
    lalomain = [stations[main_station]["lat"],stations[main_station]["long"],main_station]
    for i in stations:
        if i != main_station:
            latlong.append([stations[i]["lat"],stations[i]["long"],i])
    for x in range(len(latlong)):
        ddd.append([distance(lalomain[0], lalomain[1],latlong[x][0], latlong[x][1]),latlong[x][2]])
    ddd.sort()
    for i in ddd:
        ndis.append(i[1])
    if K > len(ddd):
        return ndis
    else:
        return ndis[0:K]
def average_temp(stations, names):
    tem = []
    for i in names:
        tem.append(stations[i]["temp"])
    return sum(tem)/len(tem)


# --------------------------------------------------
# 6330336321 (28.98) 179 (2021-03-27 01:15)

def approx_match(stations, name):
    name = name.upper()
    nameX = ''
    for i in name:
        if i != ' ':
            nameX += i
    sta = ""
    ans = []
    for i in stations:
        for j in i:
            if j != ' ':
                sta += i
        if nameX in sta:
            ans.append(i)
        sta = ''
    return ans
def top_k_min_temp_stations(stations, K):
    temp = []
    ans = []
    for k in stations:
        temp.append([stations[k]['temp'], k])
    temp.sort()
    for i in range(len(temp)):
        ans.append(temp[i][1])
    return ans[0:K:1]
def top_k_max_temp_stations(stations, K):
    temp = []
    ans = []
    for k in stations:
        temp.append([-stations[k]['temp'], k])
    temp.sort()
    for i in range(len(temp)):
        ans.append(temp[i][1])
    return ans[0:K:1]
def peak_stations(stations):
    lat_max = -math.inf
    lat_min = math.inf
    long_max = -math.inf
    long_min = math.inf
    for i in stations:
        if stations[i]['lat'] >= lat_max:
            latmaxx = i
            lat_max = max(stations[i]['lat'], lat_max)
        if stations[i]['lat'] <= lat_min:
            latminn = i
            lat_min = min(stations[i]['lat'], lat_min)
        if stations[i]['long'] >= long_max:
            longmaxx = i
            long_max = max(stations[i]['long'], long_max)
        if stations[i]['long'] <= long_min:
            longminn = i
            long_min = min(stations[i]['long'], long_min)
    return [latminn, latmaxx, longminn, longmaxx]
def k_nearby_stations(stations, main_station, K):
    lat = stations[main_station]['lat']
    long = stations[main_station]['long']
    ans = []
    check = []
    for i in stations:
        d = distance(lat, long, stations[i]['lat'], stations[i]['long'])
        check.append([d, i])
    check.sort()
    for i in range(1, len(check)):
        ans.append(check[i][1])
    return ans[0:K:1]
def average_temp(stations, names):
    sigma_temp = 0
    count = 0
    for i in names:
        sigma_temp += stations[i]['temp']
        count += 1
    return sigma_temp / count
# --------------------------------------------------
# 6330337021 (29.6) 180 (2021-03-27 01:05)

def approx_match(stations, name):

    po = []
    for c in stations :
        if clear(name) in clear(c) :
            po.append(c)
    return po
def top_k_min_temp_stations(stations, K):

    y,o  = [],[]
    for c in stations :
        y.append([stations[c]['temp'],c])
    y.sort()
    for c in y :
        o.append(c[1])
    return o[:K]
def top_k_max_temp_stations(stations, K):

    y,o  = [],[]
    for c in stations :
        y.append([-stations[c]['temp'],c])
    y.sort()
    for c in y :
        o.append(c[1])
    return o[:K]
def peak_stations(stations):

    lato = []
    longo = []
    for c in stations :
        lato.append([stations[c]['lat'],c])
        longo.append([stations[c]['long'],c])
    lato.sort()
    longo.sort()
    return lato[0][1],lato[-1][1],longo[0][1],longo[-1][1]
def k_nearby_stations(stations, main_station, K):

    u = []
    o = []
    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    for c in stations :
        u.append([distance(lat_main,long_main,stations[c]['lat'],stations[c]['long']),c])
    u.sort()
    for c in u :
        o.append(c[1])
    return o[1:K+1]
def average_temp(stations, names):

    All_temp = [stations[c]['temp'] for c in names]
    return sum(All_temp)/(len(All_temp))

# --------------------------------------------------
def clear (name) :

    return "".join(name.upper().split())
# 6330338621 (28.74) 181 (2021-03-28 15:02)

def approx_match(stations, name):

    name = name.split()
    name = ''.join(name)
    name = name.upper()
    thestat = []
    for k in stations.keys():
        k1 = k.split()
        k1 = ''.join(k1)
        k1 = k1.upper()
        x = k1.find(name)
        if x != -1:
            thestat.append(k)
    return thestat
def top_k_min_temp_stations(stations, K):

    new = {}
    for k in stations:
        new[k] = stations[k]['temp']
    new1 = dict(sorted(new.items(), key=lambda item: item[0]))
    new2 = dict(sorted(new1.items(), key=lambda item: item[1]))
    myset = list(new2)

    return myset[:K]
def top_k_max_temp_stations(stations, K):

    new = {}
    for k in stations:
        new[k] = stations[k]['temp']
    new1 = dict(sorted(new.items(), key=lambda item: item[0]))
    new2 = dict(sorted(new1.items(), key=lambda item: item[1]))
    myset = list(new2)

    return myset[:-K-1:-1]
def peak_stations(stations):

    ans = []
    new_1 = {}
    for k in stations:
        new_1[k] = stations[k]['lat']
    new1_1 = dict(sorted(new_1.items(), key=lambda item: item[0]))
    new2_1 = dict(sorted(new1_1.items(), key=lambda item: item[1]))
    myset = list(new2_1)
    ans += [myset[0],myset[-1]]

    new_2 = {}
    for k in stations:
        new_2[k] = stations[k]['long']
    new1_2 = dict(sorted(new_2.items(), key=lambda item: item[0]))
    new2_2 = dict(sorted(new1_2.items(), key=lambda item: item[1]))
    myset2 = list(new2_2)
    ans += [myset2[0],myset2[-1]]

    return ans
def k_nearby_stations(stations, main_station, K):

    dis = {}
    for k in stations:
        lat1 = stations[main_station]['lat']
        long1 = stations[main_station]['long']
        lat2 = stations[k]['lat']
        long2 = stations[k]['long']
        dis[k] = distance(lat1, long1, lat2, long2)
    dis1 = dict(sorted(dis.items(), key=lambda item: item[0]))
    dis2 = dict(sorted(dis1.items(), key=lambda item: item[1]))
    mydis = list(dis2)

    return mydis[1:K+1]
def average_temp(stations, names):

    sigmatemp = 0
    n = 0
    for e in names:
        sigmatemp += stations[e]['temp']
        n += 1
    av = sigmatemp/n

    return av

# --------------------------------------------------
# 6330339221 (28.74) 182 (2021-03-27 20:05)

def approx_match(stations, name):
    name = name.upper()
    name = name.split(' ')
    name = ''.join(name)
    allstt = []
    for i in stations :
        stt = i.split(' ')
        stt = ''.join(stt)
        if name in stt :
            allstt.append(i)
    return allstt
def top_k_min_temp_stations(stations, K):
    tempstt = []
    for i in stations :
        tempstt.append([stations[i]['temp'],i])
    tempstt.sort()
    lowktempstt = []
    for i in range(K) :
        lowktempstt.append(tempstt[i][1])
    return lowktempstt
def top_k_max_temp_stations(stations, K):
    tempstt = []
    for i in stations :
        tempstt.append([stations[i]['temp'],i])
    tempstt.sort(reverse=True)
    maxktempstt = []
    for i in range(K) :
        maxktempstt.append(tempstt[i][1])
    return maxktempstt
def peak_stations(stations):
    latstt = []
    longstt = []
    for i in stations :
        latstt.append([stations[i]['lat'],i])
        longstt.append([stations[i]['long'],i])
    sortlatstt = sorted(latstt)
    sortlongstt = sorted(longstt)
    peakstt = [sortlatstt[0][1],sortlatstt[-1][1],sortlongstt[0][1],sortlongstt[-1][1]]
    return peakstt
def k_nearby_stations(stations, main_station, K):
    alldtstt = []
    for i in stations :
        alldtstt.append([distance(stations[main_station]['lat'], stations[main_station]['long'], stations[i]['lat'], stations[i]['long']),i])
    sortdtstt = sorted(alldtstt)
    neardtstt = []
    for i in range(1, K+1) :
        if i <= len(sortdtstt) :
            neardtstt.append(sortdtstt[i][1])
    return neardtstt
def average_temp(stations, names):
    templist = []
    for i in names :
        templist.append(stations[i]['temp'])
    sumtemp = 0
    for i in templist :
        sumtemp += i
    avgtemp = sumtemp/len(templist)
    return avgtemp



# --------------------------------------------------
# 6330340821 (30) 183 (2021-03-29 18:48)

def approx_match(stations, name):
    result=[]
    aa=''
    for i in name:
        if i !=' ':
            aa+=i
    for i in stations:
        if aa.upper() in i.upper().replace(' ',''):
            result.append(i)
    return result
def top_k_min_temp_stations(stations, K):
    topstation=[[stations[i]['temp'],i] for i in stations]
    topstation.sort()
    realtop=[]
    for i in topstation[:K:]:
        realtop.append(i[1])
    return realtop
def top_k_max_temp_stations(stations, K):
    topstation=[[-stations[i]['temp'],i] for i in stations]
    topstation.sort()
    realtop=[]
    for i in topstation[:K:]:
        realtop.append(i[1])
    return realtop
def peak_stations(stations):
    la=[[stations[i]['lat'],i] for i in stations]
    la.sort()
    lamax=la[-1][1]
    lamin=la[0][1]
    lon=[[stations[i]['long'],i] for i in stations]
    lon.sort()
    lonmax=lon[-1][1]
    lonmin=lon[0][1]
    al=[]
    al.append(lamin)
    al.append(lamax)
    al.append(lonmin)
    al.append(lonmax)
    return al
def k_nearby_stations(stations, main_station, K):
    near=[]
    diss=[[distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i]for i in stations]
    diss.sort()
    for i in diss[:K+1:]:
        if i[0]!=0:
            near.append(i[1])
    return near
def average_temp(stations, names):
    altemp=0
    for i in names:
        altemp+=stations[i]['temp']
    avgtemp=altemp/len(names)
    return avgtemp


# --------------------------------------------------
# 6330341421 (30) 184 (2021-03-29 14:00)

def approx_match(stations, name):

    n = ''
    name = name.upper()
    for i in name:
        if 'A'<= i <= 'Z':
            n+=i
    nam = []
    for i in stations:
        if n in i.upper():
            nam.append(i.upper())
    return nam
def top_k_min_temp_stations(stations, K):

    st = []
    for i in stations:
        st.append([stations[i]['temp'],i])
    st.sort()
    d = []
    for i in range(K):
        if i<len(st):
            d.append(st[i][1])
    return d
def top_k_max_temp_stations(stations, K):

    st = []
    for i in stations:
        st.append([stations[i]['temp'],i])
    st.sort(reverse = True)
    d = []

    c=0
    while c != 100:
        for i in range(len(st)-1):
            if st[i][0] == st[i+1][0]:
                if st[i][1] > st[i+1][1]:
                    st[i],st[i+1] = st[i+1],st[i]
        c+=1
    for i in range(K):
        if i<len(st):
            d.append(st[i][1])
    return d
def peak_stations(stations):

    stlat = []
    for i in stations:
        stlat.append([stations[i]['lat'],i])
    stlat.sort()
    a = stlat[-1][1]
    b = stlat[0][1]

    stlong = []
    for i in stations:
        stlong.append([stations[i]['long'],i])
    stlong.sort()
    c = stlong[-1][1]
    d = stlong[0][1]
    go = [b,a,d,c]
    return go
def k_nearby_stations(stations, main_station, K):

    stdis = []
    mstla = stations[main_station]['lat']
    mstlo = stations[main_station]['long']
    for i in stations:
        stdis.append([distance(stations[i]['lat'],stations[i]['long'],mstla,mstlo),i])
    stdis.sort()
    stdis = stdis[1::]
    d = []
    for i in range(K):
        if i < len(stdis):
            d.append(stdis[i][1])
    return d
def average_temp(stations, names):

    s = []
    for i in names:
        s.append(stations[i]['temp'])
    avg = float(sum(s)/len(s))
    return avg

# --------------------------------------------------
# 6330342021 (30) 185 (2021-03-28 20:46)

def approx_match(stations, name):
    name1=''
    lis=[]
    for i in name.upper():
        if 'A'<=i<='Z':
            name1+=i
    for i in stations:
        I=''
        for k in i.upper():
            if 'A'<=k<='Z':
                I+=k
        if name1 in I:
            lis.append(i)
    return lis
def top_k_min_temp_stations(stations, K):
    lis=[]
    stations1=[]
    for i in stations:
        lis.append([stations[i]['temp'],i])
    lis.sort()
    lis=lis[0:K]
    for i in lis:
        stations1.append(i[1])
    return stations1
def top_k_max_temp_stations(stations, K):
    lis=[]
    liss=[]
    stations1=[]
    for i in stations:
        lis.append([-stations[i]['temp'],i])
    lis.sort()
    for j,k in lis:
        liss.append([-j,k])
    liss=liss[0:K]
    for i in liss:
        stations1.append(i[1])
    return stations1
def peak_stations(stations):
    lat=[]
    long=[]
    lis=[]
    for i in stations:
        lat.append([stations[i]['lat'],i])
    for i in stations:
        long.append([stations[i]['long'],i])
    lat.sort()
    long.sort()
    lis.append(lat[0][1])
    lis.append(lat[-1][1])
    lis.append(long[0][1])
    lis.append(long[-1][1])
    return lis
def k_nearby_stations(stations, main_station, K):
    stations1=[]
    dis=[]
    for i in stations:
        if i==main_station.upper():
            lat1=stations[i]['lat']
            long1=stations[i]['long']
    for i in stations:
        dis.append([distance(lat1, long1, stations[i]['lat'], stations[i]['long']),i])
    dis.sort()
    dis=dis[1:K+1]
    for i in dis:
        stations1.append(i[1])

    return stations1
def average_temp(stations, names):
    summ=0
    for i in names :
        summ+=stations[i.upper()]['temp']
    av=summ/len(names)
    return av



# --------------------------------------------------
# 6330343721 (28.02) 186 (2021-03-29 23:54)

def approx_match(stations, name):
    namereduced = ''
    for i in range(len(name)):
        if name[i] != ' ':
            namereduced+= name[i].upper()
    stationkey = list(stations.keys())
    stationkeyreduced = []
    for i in range(len(stationkey)):
        keyreduced = ''
        for j in range(len(stationkey[i])):
            if stationkey[i][j] != ' ':
                keyreduced += stationkey[i][j]
        stationkeyreduced.append(keyreduced.upper())
    searchkey = []
    for i in range(len(stationkey)):
        for j in range(len(stationkey[i])-len(namereduced)):
            if namereduced == stationkeyreduced[i][j:j+len(namereduced)]:
                searchkey.append(stationkey[i])
    return searchkey
def top_k_min_temp_stations(stations, K):
    t_min = sorted(stations, key = lambda TEMP:(stations[TEMP]['temp'], TEMP))[0:K]
    return t_min
def top_k_max_temp_stations(stations, K):
    t_max = sorted(stations, key = lambda TEMP:(-stations[TEMP]['temp'], TEMP))[0:K]
    return t_max
def peak_stations(stations):
    latitude = sorted(stations, key = lambda TEMP:(stations[TEMP]['lat']))
    placewithlowestlat, placewithhighestlat = latitude[0], latitude[-1]
    longitude = sorted(stations, key = lambda TEMP:(stations[TEMP]['long']))
    placewithlowestlong, placewithhighestlong = longitude[0], longitude[-1]
    peaklisttttttttttttttttttttttttt = [placewithlowestlat, placewithhighestlat, placewithlowestlong, placewithhighestlong]
    return peaklisttttttttttttttttttttttttt
def k_nearby_stations(stations, main_station, K):
    O = main_station #DEFINECENTER
    X_0 = stations[O]['lat'] #Spherical Coordinate of the center lat
    Y_0 = stations[O]['long'] #Spherical Coordinate of the center long
    listof_k_nearby_station = sorted(stations, key = lambda TEMP:(distance(X_0, Y_0, stations[TEMP]['lat'], stations[TEMP]['long']), TEMP))[1:K+1]
    return listof_k_nearby_station
def average_temp(stations, names):
    tempineachpart = [stations[x]['temp'] for x in names]
    sumtemp = sum(tempineachpart)
    avg_temp = sumtemp/len(tempineachpart)
    return avg_temp


# --------------------------------------------------
# 6330345021 (30) 187 (2021-03-25 21:54)

def approx_match(stations, name):
    name = name.upper()
    name_n = ""
    for i in name:
        if i in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
            name_n += i
    list_name = []
    for each_name in stations:
        each_name_n = each_name.upper()
        if name_n in each_name_n:
            list_name.append(each_name)
    return list_name
def top_k_min_temp_stations(stations, K):
    list_temp = []
    for each_name in stations:
        list_temp.append([stations[each_name]['temp'],each_name])
    list_temp.sort()
    list_temp_low = list_temp[:K]
    list_name_temp_low = []
    for i in range(len(list_temp_low)):
        list_name_temp_low.append(list_temp_low[i][1])
    return list_name_temp_low
def top_k_max_temp_stations(stations, K):
    list_temp = []
    for each_name in stations:
        list_temp.append([-stations[each_name]['temp'],each_name])
    list_temp.sort()
    list_temp_high = list_temp[:K]
    list_name_temp_high = []
    for i in range(len(list_temp_high)):
        list_name_temp_high.append(list_temp_high[i][1])
    return list_name_temp_high
def peak_stations(stations):
    list_lat = []
    for each_name_lat in stations:
        list_lat.append([stations[each_name_lat]['lat'],each_name_lat])
    name_lat_low = list_lat[0][1] ; name_lat_high = list_lat[0][1]
    lat_low = list_lat[0][0] ; lat_high = list_lat[0][0]
    for i in range(len(list_lat)):
        if list_lat[i][0] < lat_low:
            lat_low = list_lat[i][0]
            name_lat_low = list_lat[i][1]
        if list_lat[i][0] > lat_high:
            lat_high = list_lat[i][0]
            name_lat_high = list_lat[i][1]
    list_long = []
    for each_name_long in stations:
        list_long.append([stations[each_name_long]['long'],each_name_long])
    name_long_low = list_long[0][1] ; name_long_high = list_long[0][1]
    long_low = list_long[0][0] ; long_high = list_long[0][0]
    for k in range(len(list_long)):
        if list_long[k][0] < long_low:
            long_low = list_long[k][0]
            name_long_low = list_long[k][1]
        if list_long[k][0] > long_high:
            long_high = list_long[k][0]
            name_long_high = list_long[k][1]
    list_name = [name_lat_low,name_lat_high,name_long_low,name_long_high]
    return list_name
def k_nearby_stations(stations, main_station, K):
    list_distance = []
    lat_main,long_main = stations[main_station]['lat'],stations[main_station]['long']
    for each_name in stations:
        lat_each_name,long_each_name = stations[each_name]['lat'],stations[each_name]['long']
        list_distance.append([distance(lat_main, long_main, lat_each_name, long_each_name),each_name])
    list_distance.sort()
    list_dis_name = list_distance[1:K+1]
    list_name = []
    for i in range(len(list_dis_name)):
        list_name.append(list_dis_name[i][1])
    return list_name
def average_temp(stations, names):
    sum_temp = 0
    for each_name in names:
        sum_temp += stations[each_name]["temp"]
    average_temp_out = sum_temp/len(names)
    return average_temp_out

# --------------------------------------------------
# 6330346621 (30) 188 (2021-03-29 15:06)

def approx_match(stations, name):
    n=''
    for e in name:
        if e!=' ':n+=e
    n=n.upper()

    o=[]
    for key in stations:
        k=''
        for e in key:
            if e!=' ':k+=e
        if n in k:
            o.append(key)
    return o
def top_k_min_temp_stations(stations, K):
    a=[]
    for key in stations:
        a.append([stations[key]['temp'],key])
    a.sort()
    b=[]
    for i in range(K):
        b.append(a[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    a=[]
    for key in stations:
        a.append([-stations[key]['temp'],key])
    a.sort()
    b=[]
    for i in range(K):
        b.append(a[i][1])
    return b
def peak_stations(stations):
    lat=[]
    long=[]
    for key in stations:
        lat.append([stations[key]['lat'],key])
        long.append([stations[key]['long'],key])
    lat.sort()
    long.sort()
    a=[lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return a
def k_nearby_stations(stations, main_station, K):
    a=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    b=[]
    for key in stations:
        lat2=stations[key]['lat']
        long2=stations[key]['long']
        a.append([distance(lat1, long1, lat2, long2),key])
    a.sort()
    if K+1<len(a):
        for i in range(1,K+1):
            b.append(a[i][1])
    else:
        for e in a:
            b.append(e[1])
    return b
def average_temp(stations, names):
    a=0
    for e in names:
        a+=stations[e]['temp']
    b=a/len(names)
    return b



# --------------------------------------------------
# 6330347221 (30) 189 (2021-03-29 00:04)

def approx_match(stations, name):
    x = ''
    for e in name:
        if e in 'abcdefghijklmnopqrstuvwxyz' or e in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            x += e.upper()
        else:
            pass
    y = []
    for key in stations:
        if x in key:
            y.append(key)
    return y
def top_k_min_temp_stations(stations, K):
    x = []
    for key in stations:
        tempurature = stations[key]['temp']
        x.append([tempurature, key])
    x.sort()
    x = x[:K]
    y = []
    for i in range(len(x)):
        y.append(x[i][1])
    return y
def top_k_max_temp_stations(stations, K):
    x = []
    for key in stations:
        tempurature = stations[key]['temp']
        x.append([-1*tempurature, key])
    x.sort()
    x = x[:K]
    y = []
    for i in range(len(x)):
        y.append(x[i][1])
    return y
def peak_stations(stations):
    a = []
    b = []
    c = []
    for key in stations:
        latt = stations[key]['lat']
        longg = stations[key]['long']
        a.append([latt, key])
        b.append([longg, key])
    a.sort()
    c.append(a[0][1])
    for e in a:
        e[0] *= -1
    a.sort()
    c.append(a[0][1])
    b.sort()
    c.append(b[0][1])
    for e in b:
        e[0] *= -1
    b.sort()
    c.append(b[0][1])
    return c
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    a = []
    for key in stations:
        lat2 = stations[key]['lat']
        long2 = stations[key]['long']
        d = distance(lat1, long1, lat2, long2)
        a.append([d, key])
    a.sort()
    a = a[1:K+1]
    nearby = []
    for i in range(len(a)):
        nearby.append(a[i][1])
    return nearby
def average_temp(stations, names):
    all_temp = 0
    for e in names:
        tempurature = stations[e]['temp']
        all_temp += tempurature
    avg_temp = all_temp/len(names)
    return avg_temp

# --------------------------------------------------
# 6330348921 (30) 190 (2021-03-29 05:28)

def approx_match(stations, name):
    x = []
    rename = ''

    for k in name:
        if 'A'<=k.upper()<='Z':
            rename += k.upper()
    for e in stations:
        station_name = ''
        for j in e:
            if 'A'<=j.upper()<='Z' or '0'<=j.upper()<='9':
                station_name += j.upper()
        if rename in station_name:
            x.append(e)
    return x
def top_k_min_temp_stations(stations, K):
    x= []
    y = []
    for e in stations:
        x.append([stations[e]['temp'],e])
    x.sort()
    for q in range(min(K,len(stations))):
        y.append(x[q][1])
    return y
def top_k_max_temp_stations(stations, K):
    x= []
    y = []
    for e in stations:
        x.append([stations[e]['temp'],e])
    for q in range(len(x)):
        x[q][0] = (x[q][0])**-1
    x.sort()
    for j in range(len(x)):
        x[j][0] = (x[j][0])**-1
    for w in range(min(K,len(stations))):
        y.append(x[w][1])
    return y
def peak_stations(stations):
    lat = []
    long = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
        long.append([stations[e]['long'],e])
    min_lat = sorted(lat)[0][1]
    max_lat = sorted(lat,reverse=True)[0][1]
    min_long = sorted(long)[0][1]
    max_long = sorted(long,reverse=True)[0][1]

    peak = [min_lat,max_lat,min_long,max_long]
    return peak
def k_nearby_stations(stations, main_station, K):
    dist = []
    x = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for e in stations:
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        dist.append([distance(lat1,long1,lat2,long2),e])
    dist.sort()
    for q in range(1,min(len(stations),K+1)):
        x.append(dist[q][1])
    return x
def average_temp(stations, names):
    avgt = 0
    for e in names:
        avgt += stations[e]['temp']
    avgt = avgt/len(names)
    return avgt


# --------------------------------------------------
# 6330349521 (28.74) 191 (2021-03-29 21:26)

def approx_match(stations, name):
    f = ''
    l = []
    for e in name:
        if e != ' ':
            f += e.lower()
    for key in stations:
        if f in key.lower() or name.lower() in key.lower():
            l.append(key)
    return l
def top_k_min_temp_stations(stations, K):
    l = []
    l1 = []
    l2 = []
    c = 0
    for key in stations:
        c += 1
        l.append([stations[key]['temp'],key])
    l.sort()
    if c<K:
        for e in l:
            l2.append(e[1])
        return l2
    for i in range(K):
        l1.append(l[i][1])
    return l1
def top_k_max_temp_stations(stations, K):
    l = []
    l1 = []
    l2 = []
    c = 0
    for key in stations:
        c += 1
        l.append([stations[key]['temp'],key])
    l.sort()
    if c<K:
        for e in l[-1::-1]:
            l2.append(e[1])
        return l2
    for i in range(-1,-K-1,-1):
        l1.append(l[i][1])
    return l1
def peak_stations(stations):
    l = []
    l1 = []
    l2 = []
    for key in stations:
        l1.append([stations[key]['lat'],key])
        l2.append([stations[key]['long'],key])
    l1.sort()
    l2.sort()
    l.append(l1[0][1])
    l.append(l1[-1][1])
    l.append(l2[0][1])
    l.append(l2[-1][1])
    return l
def k_nearby_stations(stations, main_station, K):
    c = -1
    l1 = []
    l2 = []
    l = []
    for key in stations:
        c += 1
        d = distance(stations[key]['lat'],stations[key]['long'],stations[main_station]['lat'],stations[main_station]['long'])
        l1.append([d,key])
    l1.sort()
    if c<K:
        for i in range(1,c+1,1):
            l.append(l1[i][1])
        return l
    for i in range(1,K+1,1):
        l.append(l1[i][1])
    return l
def average_temp(stations, names):
    c = 0
    tt = 0
    for key in stations:
        if key in names:
            c += 1
            tt += stations[key]['temp']
    return tt/c

# --------------------------------------------------
# 6330350021 (30) 192 (2021-03-28 22:08)

def approx_match(stations, name):
    a = remove_space(name)
    b = []
    for key in stations:
        if a != '':
            if a in key.upper():
                b.append(key)
    return b
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for key in stations:
        a.append([stations[key]['temp'],key])
    a.sort()

    for i in range(min(K,len(a))):
        b.append(a[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for key in stations:
        a.append([-stations[key]['temp'],key])
    a.sort()
    for i in range(min(K,len(a))):
        b.append(a[i][1])
    return b
def peak_stations(stations):
    a = []
    b = []
    for key in stations:
        a.append([stations[key]['lat'],key])
        b.append([stations[key]['long'],key])
    a.sort()
    b.sort()
    c = [a[0][1],a[-1][1],b[0][1],b[-1][1]]
    return c
def k_nearby_stations(stations, main_station, K):
    a = []
    b = []
    for key in stations:
        z = distance(stations[main_station]['lat'],stations[main_station]['long'],stations[key]['lat'],stations[key]['long'])
        a.append([z,key])
    a.sort()
    for i in range(min(K+1,len(a))):
        if a[i][1] != main_station:
            b.append(a[i][1])
    return b
def average_temp(stations, names):
    a = 0
    for i in names:
        a += stations[i]['temp']
    b = a/len(names)
    return b

# --------------------------------------------------
def remove_space(string):
    a = ''
    for i in string:
        if 'A'<=i<='Z' or 'a'<=i<='z' :
            a += i.upper()
        elif i == ' ':
            pass
        else:
            a = ''
            break
    return a
# 6330351721 (30) 193 (2021-03-28 22:25)

def approx_match(stations,name):
    x = ''
    k = []
    name = name.upper()
    for i in range(len(name)):
        if 'A' <= name[i] <= 'Z':
            x += name[i]

    for i in stations:
        y = i.upper()
        if x in y:
            k.append(i)
    return k
def top_k_min_temp_stations(stations, K):
    x = []

    for i in stations:
        x.append([i,stations[i]['temp']])
    x.sort()
    xx = []
    for i in x:
        xx.append([i[1],i[0]])
    xx.sort()
    y = []
    for c in xx:
        y.append(c[1])

    return y[:K]
def top_k_max_temp_stations(stations, K):
    x = []

    for i in stations:
        x.append([i,stations[i]['temp']])
    x.sort()

    xx = []
    for i in x:
        xx.append([-1*i[1],i[0]])
    xx.sort()
    y = []
    for c in xx:
        y.append(c[1])
    return y[:K]
def peak_stations(stations):
    a = []
    b = []
    ans = []
    for i in stations:
        a.append([stations[i]['lat'],i])
        b.append([stations[i]['long'],i])
    a.sort()
    b.sort()
    ans.append(a[0][1])
    ans.append(a[-1][1])
    ans.append(b[0][1])
    ans.append(b[-1][1])
    return ans
def k_nearby_stations(stations, main_station, K):
    x = []
    sta = []
    for i in stations:
        x.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i])
    x.sort()

    for i in range(K+1):
        sta.append(x[i][1])

    return sta[1:K+1]
def average_temp(stations, names):
    a = 0
    for c in names:
        a += stations[c]['temp']
    a = a/len(names)
    return a



# --------------------------------------------------
# 6330352321 (30) 194 (2021-03-26 20:12)

def approx_match(stations, name):
    n = ""
    l1 = []
    l2 = []
    nl = []
    for e in name:
        if "A" <= e.upper() <= "Z":
            n += e.upper()
    for e in stations:
        s1 = ""
        s2 = ""
        for c in e:
            if "A" <= c <= "Z":
                s1 += c
                s2 += c
            elif c != " ":
                s2 += c
            else:
                s1 += c
                s2 += c
        l1.append(s1)
        l2.append(s2)
        s1 = ""
        s2 = ""
    for i in range(len(l1)):
        if n in l1[i]:
            nl.append(l2[i])
    return nl
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    if len(a) < K:
        for i in range(len(a)):
            b.append(a[i][1])
    else:
        for i in range(K):
            b.append(a[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for e in stations:
        a.append([-(stations[e]['temp']),e])
    a.sort()
    if len(a) < K:
        for i in range(len(a)):
            b.append(a[i][1])
    else:
        for i in range(K):
            b.append(a[i][1])
    return b
def peak_stations(stations):
    lat = []
    long = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
        long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    a = []
    a.append(lat[0][1])
    a.append(lat[-1][1])
    a.append(long[0][1])
    a.append(long[-1][1])
    return a
def k_nearby_stations(stations, main_station, K):
    a = []
    b = []
    for e in stations:
        c = ((stations[e]['lat']-stations[main_station]['lat'])**2+(stations[e]['long']-stations[main_station]['long'])**2)**0.5
        a.append([c,e])
    a.sort()
    if len(a)-1 < K:
        for i in range(1,len(a)):
            b.append(a[i][1])
    else:
        for i in range(1,K+1):
            b.append(a[i][1])
    return b
def average_temp(stations, names):
    a = 0
    b = 0
    c = 0
    for e in names:
        a += stations[e]['temp']
        b += 1
    c = a/b
    return c

# --------------------------------------------------
# 6330353021 (30) 195 (2021-03-28 18:58)

def approx_match(stations, name):
    l = []
    if  ' ' in name :
        name = name.split(' ')
        name = ''.join(name)
    name = name.upper()
    for i in stations :
        i = i.upper()
        if name in i :
           l.append(i)
    return l
def top_k_min_temp_stations(stations, K):
    l = []
    for i in stations :
        l.append([stations[i]['temp'],i])
    l.sort()
    x = []
    if int(K) > int(len(l)) :
        K = int(len(l))
    for i in range (0,int(K),1) :
        x.append(l[i][1])
    return x
def top_k_max_temp_stations(stations, K):
    l = []
    for i in stations :
        l.append([-float(stations[i]['temp']),i])
    l.sort()
    x = []
    if int(K) > int(len(l)) :
        K = int(len(l))
    for i in range (0,int(K),1) :
        x.append(l[i][1])
    return x
def peak_stations(stations):
    snlat = []
    for i in stations :
        snlat.append([i,stations[i]['lat']])
    lat = []
    for i in range(len(snlat)) :
        lat.append(str(snlat[i][1]))
    s = []
    for i in range (len(lat)) :
        s.append(float(lat[i]))
    lat = s
    lat.sort()
    for i in snlat :
        if lat[0] == i[1] :
            minlat = i[0]
        elif lat[-1] == i[1] :
            maxlat = i[0]
    snlong = []
    for i in stations :
        snlong.append([i,stations[i]['long']])
    long = []
    for i in range(len(snlong)) :
        long.append(str(snlong[i][1]))
    s = []
    for i in range (len(long)) :
        s.append(float(long[i]))
    long = s
    long.sort()
    for i in snlong :
        if long[0] == i[1] :
            minlong = i[0]
        elif long[-1] == i[1] :
            maxlong = i[0]
    return [minlat,maxlat,minlong,maxlong]
def k_nearby_stations(stations, main_station, K):
    l = []
    for i in stations :
        l.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i])
    l.sort()
    for  i in range(len(l)) :
        if l[i][1] == main_station :
            l[i] = ['','']
    l.remove(['',''])
    q = []
    if int(K) >int(len(l)) :
        for i in range(len(l)) :
            q.append(l[i][1])
        return q[:len(l):]
    for i in range (0,int(K),1) :
            q.append(l[i][1])

    return q[:int(K):]
def average_temp(stations, names):
    t = []
    for i in names :
         if i in stations :
                t.append(float(stations[i]['temp']))
    return sum(t)/len(t)


# --------------------------------------------------
# 6330354621 (26) 196 (2021-03-29 22:32)

def approx_match(stations, name):
    liststa=[]
    n=name.upper().split()
    n=''.join(n)
    for i in stations:
        if i.find(n)!=-1:
            liststa.append(i)
    return liststa
def top_k_min_temp_stations(stations, K):
    liststa=[]
    tempsta={}
    listtemp=[]
    for i in stations:
        temp1=stations[i]['temp']
        tempsta[temp1]= i
    for j in tempsta:
        listtemp.append(j)
    l=sorted(listtemp)
    l=l[0:K]
    for k in l:
        for i in stations:
            temp1=stations[i]['temp']
            if k == temp1:
                liststa.append(i)
    return liststa
def top_k_max_temp_stations(stations, K):
    liststa=[]
    tempsta={}
    listtemp=[]
    for i in stations:
        temp1=stations[i]['temp']
        tempsta[temp1]= i
    for j in tempsta:
        listtemp.append(j)
    l=sorted(listtemp,reverse=True)
    l=l[0:K]
    for m in l:
        for i in stations:
            temp1=stations[i]['temp']
            if m == temp1:
                liststa.append(i)
    return liststa
def peak_stations(stations):
    b=0
    c=100
    ans=[]
    for i in stations:
        a=stations[i]['long']
        b=max(a,b)
        c=min(a,c)
    for j in stations:
        if stations[j]['long'] == b:
            ans.append(j)
        if stations[j]['long'] == c:
            ans.append(j)
    b=0
    c=100
    for i in stations:
        a=stations[i]['lat']
        b=max(a,b)
        c=min(a,c)
    for j in stations:
        if stations[j]['lat'] == b:
            ans.append(j)
        if stations[j]['lat'] == c:
            ans.append(j)
    return ans
def k_nearby_stations(stations, main_station, K):
    M=main_station.upper()
    long1=stations[M]['long']
    la1=stations[M]['lat']
    dislist=[]
    disdict={}
    ans=[]
    for i,j in stations.items():
        long2=j['long']
        la2=j['lat']
        dis=distance(la1,long1,la2,long2)
        dislist.append(dis)
        disdict[dis]=i
    dislist.sort()
    k=dislist[1:K+1]
    for m in k:
        ans.append(disdict[m])
    return ans


#Mae hong son
def average_temp(stations, names):
    avg=0
    for i in names:
        avg+=float(stations[i.upper()]['temp'])
    ans=avg/len(names)
    return ans




# --------------------------------------------------
# 6330355221 (30) 197 (2021-03-29 22:20)

def approx_match(stations, name):
    list_second = []
    list_fisrt =''
    for q_z in name:
        if q_z != ' ': list_fisrt += q_z
    list_fisrt = list_fisrt.upper()
    for s_t_n in stations.keys():
        xx = ''
        for i in s_t_n :
            if i != ' ': xx += i
        xx = xx.upper()
        if list_fisrt in xx : list_second.append(s_t_n)
    return list_second

# --------------------------------------------------
def top_k_min_temp_stations(stations, K):
    sortedforlist = []
    listsecondly = []
    for i in stations : sortedforlist += [[stations[i]["temp"],i]]
    for i in sorted(sortedforlist)[0:K] : listsecondly += [i[1]]
    return listsecondly

# --------------------------------------------------
def top_k_max_temp_stations(stations, K):
    first_Ru = list(stations.keys())
    listnew = []
    for i in range(K):
        minlessness = min(first_Ru,key = lambda e:-stations[e]['temp'])
        first_Ru.remove(minlessness)
        listnew.append(minlessness)
    minlessness = min(first_Ru,key=lambda e:-stations[e]['temp'])
    first_Ru.remove(minlessness)
    while stations[minlessness]['temp'] == \
    -stations[listnew[-1]]['temp'] and len(first_Ru) > 0:
        listnew.append(minlessness)
        minlessness = min(first_Ru, key = lambda e: -stations[e]['temp'])
        first_Ru.remove(minlessness)
    listnew.sort(key=lambda e:-stations[e]['temp'])
    return listnew[:K]

# --------------------------------------------------
def peak_stations(stations):
    contractioncode = []
    vichacom = []
    peakingin = []
    state = []
    for q_r in stations : state += [[stations[q_r]['long'],q_r]]
    for q_r in sorted(state) : peakingin  += [q_r[1]]
    latitude = peakingin[-1]
    constant = peakingin[0]
    for train in stations : vichacom += [[stations[train]['lat'],train]]
    for source in sorted(vichacom) : contractioncode += [source[1]]
    codeminusone = contractioncode[-1]
    codezero = contractioncode[0]
    return[codezero,codeminusone,constant,latitude]

# --------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    K = K + 1
    progestion_008 = list(stations.keys())
    longest = stations[main_station]['long']
    listfornearby = []
    sortlastted = stations[main_station]['lat']
    for i in range(K):
        minnimumforprogestion = min(progestion_008,key = lambda e:distance \
                                    (sortlastted,longest,stations[e]['lat'],stations[e]['long']))
        listfornearby.append(minnimumforprogestion)
        progestion_008.remove(minnimumforprogestion)
    minnimumforprogestion = min(progestion_008,key = lambda e:distance \
                                (sortlastted,longest,stations[e]['lat'],stations[e]['long']))
    progestion_008.remove(minnimumforprogestion)
    while len(progestion_008) and distance(sortlastted,longest,stations[minnimumforprogestion]['lat'],stations[minnimumforprogestion]['long']) == \
    distance(sortlastted,longest,stations[listfornearby[-1]]['lat'],stations[listfornearby[-1]]['long'])  > 0:
        listfornearby.append(minnimumforprogestion)
        minnimumforprogestion = min(progestion_008, key = lambda e: distance \
                                    (sortlastted,longest,stations[e]['lat'],stations[e]['long']))
        progestion_008.remove(minnimumforprogestion)
    listfornearby.sort()
    listfornearby.sort(key = lambda e:distance \
                       (sortlastted,longest,stations[e]['lat'],stations[e]['long']))
    return listfornearby[1:K+1]

# --------------------------------------------------
def average_temp(stations, names):
    question = 0
    for q_wa in names :
        question += stations[q_wa]["temp"]
    return (question/len(names))

# --------------------------------------------------
# 6330356921 (28.74) 198 (2021-03-27 20:10)

def approx_match(stations, name):
    name1=""
    for i in range(len(name)) :
        if name[i]==" ":
            name1 += ""
        else :
            name1 += name[i].upper()
    a=[]
    b=[]
    for i in stations :
        b.append(i)
    c=[]
    for i in stations :
       i = i.split()
       i ="".join(i)
       a.append(i)
    for i in range(len(a)) :
        if name1 in a[i] :
            c.append(b[i])
    return c
# --------------------------------------------------
def top_k_min_temp_stations(stations, K):
    a=[]
    b=[]
    c=[]
    d=[]
    for i in stations :
        a.append([i,(stations[i]['temp'])])
    for [a1,a2] in a :
        b.append([a2,a1])
    b.sort()
    for [a1,a2] in b:
        c.append([a2,a1])
    for i in range(len(b)) :
        if K!=0 :
            d.append(c[i][0])
            K-=1
        else :
            break
    return d
#---------------------------------------------------
def top_k_max_temp_stations(stations, K):
    a=[]
    b=[]
    c=[]
    d=[]
    for i in stations :
        a.append([i,(stations[i]['temp'])])
    for [a1,a2] in a :
        b.append([a2,a1])
    b.sort(reverse=True)
    for [a1,a2] in b:
        c.append([a2,a1])
    for i in range(len(b)) :
        if K!=0 :
            d.append(c[i][0])
            K-=1
        else :
            break
    return d
#----------------------------------------------------
def peak_stations(stations):
    a=[]
    b=[]
    c=[]
    d=[]
    e=[]
    f=[]
    g=[]
    for i in stations :
        a.append([i,(stations[i]['lat'])])
    for [a1,a2] in a :
        b.append([a2,a1])
    b.sort()
    for [a1,a2] in b:
        c.append([a2,a1])
    d.append(c[0][0])
    d.append(c[-1][0])
    for i in stations :
        e.append([i,(stations[i]['long'])])
    for [a1,a2] in e :
        f.append([a2,a1])
    f.sort()
    for [a1,a2] in f:
        g.append([a2,a1])
    d.append(g[0][0])
    d.append(g[-1][0])
    return d
#----------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    a=[(stations[main_station]["lat"]),(stations[main_station]["long"])]
    b=[]
    c=[]
    d=[]
    e=[]
    f=[]
    for i in stations :
        b.append([i,(stations[i]['lat']),(stations[i]['long'])])
    for i in range(len(b)) :
       c.append([b[i][0], distance(a[0], a[1], b[i][1], b[i][2])])
    for [a1,a2] in c :
        d.append([a2,a1])
    d.sort()
    for [a1,a2] in d :
        e.append([a2,a1])
    for i in range(len(e)) :
        if K!=0 :
            f.append(e[i+1][0])
            K-=1
        else :
            break
    return f
#----------------------------------------------------
def average_temp(stations, names):
    a=0
    b=0
    for i in range(len(names)) :
        if names[i] in stations :
            a+=stations[names[i]]["temp"]
            b+=1
    c=float(a/b)
    return c
# --------------------------------------------------
# 6330357521 (30) 199 (2021-03-29 20:41)

def approx_match(stations, name):
    name = name.replace(" ", "").lower()
    return [station for station in stations.keys() if name in station.lower()]
def top_k_min_temp_stations(stations, K):
    if K > len(stations):
        K = len(stations)
    stations = dict(sorted(stations.items(), key=lambda station: (station[1]['temp'], station[0].lower())))
    return list(stations.keys())[:K]
def top_k_max_temp_stations(stations, K):
    if K > len(stations):
        K = len(stations)
    stations = dict(sorted(stations.items(), key=lambda station: (-station[1]['temp'], station[0].lower())))
    return list(stations.keys())[:K]
def peak_stations(stations):
    return [get_peak(stations, min, 'lat'), get_peak(stations, max, 'lat'), get_peak(stations, min, 'long'), get_peak(stations, max, 'long')]
def k_nearby_stations(stations, main_station, K):
    if K > len(stations):
        K = len(stations)
    lat = stations[main_station]['lat']
    long = stations[main_station]['long']

    for station, info in stations.items():
        stations[station]['dist'] = distance(lat, long, info['lat'], info['long'])
    stations = dict(sorted(stations.items(), key=lambda station: (station[1]['dist'], station[0].lower())))
    return list(stations.keys())[1:K+1]
def average_temp(stations, names):
    temps = [stations[name]['temp'] for name in names]
    return sum(temps)/len(temps)

# --------------------------------------------------
def get_peak(stations, func, key):
    return func(stations, key=lambda station: stations[station][key])
# 6330358121 (30) 200 (2021-03-29 23:24)

def approx_match(stations, name):
    nam=word(name.upper());g=[]
    for e in stations:
        if nam in word(e.upper()):g.append(e)
    return g
def top_k_min_temp_stations(stations, K):
    l=[];g=[]
    for e in stations:
        l.append([stations[e]['temp'],e])
    l.sort()
    for j in l:g.append(j[1])
    return g[:min(len(g),K)]
def top_k_max_temp_stations(stations, K):
    for e in stations:stations[e]['temp']=-stations[e]['temp']
    m=top_k_min_temp_stations(stations, K)
    for n in stations:stations[n]['temp']=-stations[n]['temp']
    return m
def peak_stations(stations):
    llat=[];llong=[];w=stations
    for e in stations:
        llat.append(stations[e]['lat'])
        llong.append(stations[e]['long'])
        a=search(w,'lat',min(llat));b=search(w,'lat',max(llat))
        c=search(w,'long',min(llong));d=search(w,'long',max(llong))
    return [a,b,c,d]
def k_nearby_stations(stations, main_station, K):
    p=stations[main_station];lat0=p['lat'];long0=p['long']
    g=[];h=[]
    for e in stations:
        q=stations[e];u=distance(q['lat'], q['long'], lat0, long0)
        g.append([u,e])
    g.sort()
    for j in g:h.append(j[1])
    return h[1:min(len(h),K+1)]
def average_temp(stations, names):
    l=[]
    for e in names:l.append(stations[e]['temp'])
    return sum(l)/len(l)
# --------------------------------------------------
def word(t):return ''.join(list(t.split()))
def search(d,p,q):
    for e in d:
        if d[e][p]==q:return e
# 6330360321 (30) 201 (2021-03-29 03:22)

def approx_match(stations, name):
    name = name.upper()
    a = ''
    for e in name :
        if 'A'<=e<='Z' :
            a += e
    a = a.split()
    a = ''.join(a)
    d = []
    for n in stations :
        n = str(n)
        n = n.upper()
        if a in n :
            d.append(n)
    return d
def top_k_min_temp_stations(stations, K):
    n = []
    for i in stations :
        b = un_com_temp(stations.get(i))
        n.append([b,i])
    n.sort(key=None, reverse=False)
    d = 0
    o =[]
    while d <= K :
        f,g = n[d]
        e = 1
        j = [g]
        while True :
            f1,g1 = n[d+e]
            if f == f1 :
                j.append(g1)
                e += 1
            else :
                break
        j.sort(key=None, reverse=False)
        o += j
        d += len(j)
    return o[0:K]
def top_k_max_temp_stations(stations, K):
    n = []
    for i in stations :
        b = un_com_temp(stations.get(i))
        n.append([b,i])
    n.sort(key=None, reverse=True)
    d = 0
    o =[]
    while d <= K :
        f,g = n[d]
        e = 1
        j = [g]
        while True :
            f1,g1 = n[d+e]
            if f == f1 :
                j.append(g1)
                e += 1
            else :
                break
        j.sort(key=None, reverse=False)
        o += j
        d += len(j)
    return o[0:K]
def peak_stations(stations):
    z = []
    for n in stations:
        d = un_com_z(stations.get(n))
        z.append([d,n])
    z.sort(key=None, reverse=True)

    z_max = z[0][1]
    z_min = z[-1][1]
    x = []
    for e in stations:
        b = un_com_x(stations.get(e))
        x.append([b,e])
    x.sort(key=None, reverse=True)
    x_max = x[0][1]
    x_min = x[-1][1]
    c = [z_min,z_max,x_min,x_max]
    return c
def k_nearby_stations(stations, main_station, K):
    d =[]
    for n in stations :
        e = distance(un_com_z(stations.get(n)),un_com_x(stations.get(n)),un_com_z(stations.get(main_station)),un_com_x(stations.get(main_station)))
        d.append([e,n])
    d.sort(key=None, reverse=False)
    n = 0
    o =[]
    while n <= K :
        f,g = d[n]
        e = 1
        j = [g]
        while True :
            f1,g1 = d[n+e]
            if f == f1 :
                j.append(g1)
                e += 1
            else :
                break
        j.sort(key=None, reverse=False)
        o += j
        n += len(j)
    return  o[1:K+1]
def average_temp(stations, names):
    b = 0
    for n in names :
        a = stations.get(n)
        b += un_com_temp(a)
    c = b/len(names)
    return c





# --------------------------------------------------
def un_com_temp(com) :
    a = com.get('temp')
    return a
def un_com_z(com):
    a = com.get('lat')
    return a
def un_com_x(com):
    a = com.get('long')
    return a
#
# 6330361021 (30) 202 (2021-03-29 00:21)

def approx_match(stations, name):
    n = ''
    lst_station = []
    for i in name:
        if i in alphabet:
            n += i.upper()
    for i in stations:
        station_name = ''
        for j in i :
            if j in alphabet:
                station_name += j.upper()
        if n in station_name:
            lst_station.append(i)
    return lst_station
def top_k_min_temp_stations(stations, K):
    lst_temp_name = []
    min_name = []
    for s,e in stations.items():
        lst_temp_name.append([e['temp'],s])
    lst_temp_name.sort()
    for i in lst_temp_name:
        min_name.append(i[1])
        if len(min_name) == K:
            break
    return min_name
def top_k_max_temp_stations(stations, K):
    lst_temp_name = []
    max_name = []
    for s,e in stations.items():
        lst_temp_name.append([-e['temp'],s])
    lst_temp_name.sort()
    for i in lst_temp_name:
        max_name.append(i[1])
        if len(max_name) == K:
            break
    return max_name
def peak_stations(stations):
    lst_lat_station = []
    lst_long_station = []
    for s,e in stations.items():
        lst_lat_station.append([e['lat'],s])
        lst_long_station.append([e['long'],s])
    lst_lat_station.sort()
    lst_long_station.sort()
    lst_peak = [lst_lat_station[0][1],lst_lat_station[-1][1],lst_long_station[0][1],lst_long_station[-1][1]]
    return lst_peak
def k_nearby_stations(stations, main_station, K):
    lst_distance_name = []
    near_name = []
    for s,e in stations.items():
        m_latlong = [stations[main_station]['lat'],stations[main_station]['long']]
        d = distance(m_latlong[0], m_latlong[1], e['lat'], e['long'])
        if d!=0:
            lst_distance_name.append([d,s])
    lst_distance_name.sort()
    for i in lst_distance_name:
        near_name.append(i[1])
        if len(near_name) == K:
            break
    return near_name
def average_temp(stations, names):
    name_temp = []
    sum_temp = 0
    for i in names:
        sum_temp += stations[i]['temp']
    avg_temp = sum_temp/len(names)
    return avg_temp

# --------------------------------------------------
# 6330362621 (30) 203 (2021-03-29 01:41)

def approx_match(stations, name):
    names=''
    for e in name:
        if e != ' ':
            names+=e
    names=names.upper()
    named = []

    for station in stations.keys():
        t=''
        for e in station:
            if e != ' ':
                t+=e
        t=t.upper()
        if names in t:
            named.append(station)
    return named
def top_k_min_temp_stations(stations, K):
    l=list(stations.keys())
    kl=[]

    for i in range(K):
        minl = min(l,key=lambda e:stations[e]['temp'])
        l.remove(minl)
        kl.append(minl)
    minl = min(l,key=lambda e:stations[e]['temp'])
    l.remove(minl)

    while stations[minl]['temp'] == stations[kl[-1]]['temp'] and len(l) > 0:
        kl.append(minl)
        minl = min(l, key=lambda e: stations[e]['temp'])
        l.remove(minl)
    kl.sort()
    kl.sort(key=lambda e:stations[e]['temp'])
    return kl[:K]
def top_k_max_temp_stations(stations, K):
    l=list(stations.keys())

    kl=[]

    for i in range(K):
        minl = min(l,key=lambda e:-stations[e]['temp'])
        l.remove(minl)
        kl.append(minl)
    minl = min(l,key=lambda e:-stations[e]['temp'])
    l.remove(minl)

    while stations[minl]['temp'] == -stations[kl[-1]]['temp'] and len(l) > 0:
        kl.append(minl)
        minl = min(l, key=lambda e: -stations[e]['temp'])
        l.remove(minl)
    kl.sort()
    kl.sort(key=lambda e:-stations[e]['temp'])
    return kl[:K]
def peak_stations(stations):
    l = list(stations.keys())
    minlat = min(l,key=lambda e: stations[e]['lat'])
    minlong = min(l, key=lambda e: stations[e]['long'])
    maxlat = max(l, key=lambda e: stations[e]['lat'])
    maxlong = max(l, key=lambda e: stations[e]['long'])

    ans = [minlat,maxlat,minlong,maxlong]

    return ans
def k_nearby_stations(stations, main_station, K):
    K=K+1
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']

    l=list(stations.keys())
    kl=[]

    for i in range(K):
        minl = min(l,key=lambda e:distance(lat1,long1,stations[e]['lat'],stations[e]['long']))
        l.remove(minl)
        kl.append(minl)
    minl = min(l,key=lambda e:distance(lat1,long1,stations[e]['lat'],stations[e]['long']))
    l.remove(minl)

    while distance(lat1,long1,stations[minl]['lat'],stations[minl]['long']) == distance(lat1,long1,stations[kl[-1]]['lat'],stations[kl[-1]]['long']) and len(l) > 0:
        kl.append(minl)
        minl = min(l, key=lambda e: distance(lat1,long1,stations[e]['lat'],stations[e]['long']))
        l.remove(minl)
    kl.sort()
    kl.sort(key=lambda e:distance(lat1,long1,stations[e]['lat'],stations[e]['long']))
    return kl[1:K+1]
def average_temp(stations, names):
    average=0
    for name in names:
        average+=stations[name]['temp']
    average=average/(len(names))
    return average



# --------------------------------------------------
# 6330365521 (30) 204 (2021-03-26 15:41)

def approx_match(stations, name):
    name=name.upper()
    nam=''

    for i in name:
        if i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            nam+=i
    liname=[]
    for a in stations:
        if nam in a:
            liname.append(a)
    return liname
def top_k_min_temp_stations(stations, K):
    tempsta=[]
    for a in stations:
        tempsta.append([stations[a]['temp'],a])
    tempsta.sort()
    retemp=[]
    ch=0
    for i in range (len(tempsta)):
        if ch<K:
            retemp.append(tempsta[i][1])
            ch+=1
        else: break
    return retemp
def top_k_max_temp_stations(stations, K):
    tempsta=[]

    for a in stations:
        tempsta.append([-stations[a]['temp'],a])
    tempsta.sort()
    retemp=[]
    ch=0
    for i in range (len(tempsta)):
        if ch<K:
            retemp.append(tempsta[i][1])
            ch+=1
        else: break
    return retemp
def peak_stations(stations):
    latmax=-99999
    latmin=999999
    longmax=-99999
    longmin=999
    x=[]
    for a in stations:
        if latmax < stations[a]['lat']:
            latmax= stations[a]['lat']
        if latmin > stations[a]['lat']:
            latmin= stations[a]['lat']
        if longmax < stations[a]['long']:
            longmax= stations[a]['long']
        if longmin> stations[a]['long']:
            longmin= stations[a]['long']

    for a in stations :
        if latmin == stations[a]['lat']:
            x.append(a)
            break
    for a in stations :
        if latmax == stations[a]['lat']:
            x.append(a)
            break
    for a in stations :
        if longmin == stations[a]['long']:
            x.append(a)
            break
    for a in stations :
        if longmax == stations[a]['long']:
            x.append(a)
            break
    return x
def k_nearby_stations(stations, main_station, K):
    main_station=main_station.upper()
    dis=[]
    for a in stations:
        dis.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[a]['lat'],stations[a]['long']),a])
    dis.sort()
    x=[]
    ch=0
    for i in range(1,len(dis)):
        if ch < K:
            a,b=dis[i]
            x.append(b)
            ch+=1
        else: break
    return x
def average_temp(stations, names):
    i=0
    su=0
    for x in names:
        y=stations[x]['temp']
        su+=y
        i+=1
    return su/i


# --------------------------------------------------
# 6330366121 (30) 205 (2021-03-29 00:22)

def approx_match(stations, name):

   name = name.upper()
   x = ""
   Joestar = []
   for r in name:
        if r != " ":
            x += r
   for y in stations:
       if x in y:
           Joestar.append(y)

   return Joestar
def top_k_min_temp_stations(stations, K):

    Dio = []
    Vamu = []

    for e in stations:
      stations[e]['temp']
      Dio.append([stations[e]['temp'],e])

    Dio.sort()
    i = 0
    if K >= len(Dio):
        for b in range (len(Dio)):
            Vamu.append(Dio[b][1])
    else:
        while i < K :
            Vamu.append(Dio[i][1])
            i += 1

    return Vamu
def top_k_max_temp_stations(stations, K):

    Joseph = []
    Jotaro = []
    for e in stations:
      stations[e]['temp']
      Joseph.append([-stations[e]['temp'],e])

    Joseph.sort()
    i = 0
    if K >= len(Joseph):
        for a in range (len(Joseph)):
            Jotaro.append(Joseph[a][1])



    else:
        while i < K :
            Jotaro.append(Joseph[i][1])
            i += 1

    return Jotaro
def peak_stations(stations):

    Stand = []

    Star = []
    Platinum = []

    for f in stations:
        X=[stations[f]['lat'],f]
        Star.append(X)
    Star = sorted(Star)
    Latmin = Star[0][1]
    Latmax = Star[-1][1]

    The = []
    World = []
    for f in stations:
        Y=[stations[f]['long'],f]
        The.append(Y)
    The = sorted(The)
    Longmin = The[0][1]
    Longmax = The[-1][1]

    Stand = [Latmin,Latmax,Longmin,Longmax]


    return Stand
def k_nearby_stations(stations, main_station, K):


    Crazy = []
    Bizzare = []
    i=0

    for c in stations:
        lat1=stations[main_station.upper()]['lat']
        lat2=stations[c]['lat']
        long1=stations[main_station.upper()]['long']
        long2=stations[c]['long']
        Josuke = distance(lat1,long1,lat2,long2)
        if float(Josuke) == 0.0:
            continue
        else:
            Crazy.append([Josuke,c])
    Diamond = sorted(Crazy)

    while i < K :
       Bizzare.append(Diamond[i][1])
       i += 1

    return Bizzare
def average_temp(stations, names):
    Golden = []
    c = 0
    for e in names:
     stations[e]['temp']
     Golden.append(stations[e]['temp'])


    for i in Golden :
        c += float(i)

    Giorno = c/len(Golden)

    return Giorno


# --------------------------------------------------
# 6330367821 (30) 206 (2021-03-28 16:36)

def approx_match(stations, name):
    name1 = ''
    for a in name:
        if a in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
            name1 += a
    name = name1.upper()
    k = []
    for i in stations.keys():
        if name in i:
            k.append(i)
    return k
def top_k_min_temp_stations(stations, K):
    a = []
    for i in stations.keys():
        a.append([stations[i]['temp'], i])
    a.sort()
    b = []
    for i in range(0, K, 1):
        b.append(a[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    for i in stations.keys():
        a.append([stations[i]['temp'], i])
    a.sort()
    d = []
    for b, c in a:
        d.append([-b, c])
    d.sort()
    e = []
    for i in range(0, K, 1):
        e.append(d[i][1])
    return e
def peak_stations(stations):
    a = []
    for i in stations.keys():
        a.append([stations[i]['lat'], i])
    a.sort()
    b = []
    for i in stations.keys():
        b.append([stations[i]['long'], i])
    b.sort()
    c = [a[0][1], a[-1][1], b[0][1], b[-1][1]]
    return c
def k_nearby_stations(stations, main_station, K):
    a = []
    for i in stations.keys():
        a.append([distance(stations[main_station]['lat'], stations[main_station]['long'], stations[i]['lat'], stations[i]['long']), i])
    a.sort()
    b = []
    for i in range(1, K+1, 1):
        b.append(a[i][1])
    return b
def average_temp(stations, names):
    a = 0
    for i in names:
        a += stations[i]['temp']
        b = a/len(names)
    return b

# --------------------------------------------------
# 6330370621 (30) 207 (2021-03-28 19:48)

def approx_match(stations, name):
    name = name.upper()
    n = ''
    pr = []
    for i in range(len(name)):
        if name[i] != ' ':
            n += name[i]
    for e in stations:
        k = e.find(n)
        if k != -1:
            pr.append(e)
    return pr
def top_k_min_temp_stations(stations, K):
    all_pr = []
    for e in stations:
        all_pr.append([stations[e]['temp'], e])
    all_pr.sort()
    prov = []
    if len(all_pr)>= K:
        for i in range(K):
            prov.append(all_pr[i][1])
    else:
        for i in range(len(all_pr)):
            prov.append(all_pr[i][1])
    return prov
def top_k_max_temp_stations(stations, K):
    all_pr = []
    for e in stations:
        all_pr.append([(-1)*stations[e]['temp'], e])
    all_pr.sort()
    prov = []
    if len(all_pr)>= K:
        for i in range(K):
            prov.append(all_pr[i][1])
    else:
        for i in range(len(all_pr)):
            prov.append(all_pr[i][1])
    return prov
def peak_stations(stations):
    lat = []
    long = []
    for e in stations:
        lat.append([stations[e]['lat'], e])
        long.append([stations[e]['long'], e])
    lat.sort(); long.sort()
    a = lat[0][1]; b = lat[-1][1]; c = long[0][1]; d = long[-1][1]
    f = [a, b, c, d]
    return f
def k_nearby_stations(stations, main_station, K):
    dist = []
    a = stations[main_station]['lat']
    b = stations[main_station]['long']
    for e in stations:
        c = stations[e]['lat']
        d = stations[e]['long']
        dist.append([distance(c, d, a, b), e])
    dist.sort()
    near = []
    if len(dist)>= K+1:
        for i in range(1, K+1):
            near.append(dist[i][1])
    else:
        for i in range(len(1, dist+1)):
            near.append(dist[i][1])
    return near
def average_temp(stations, names):
    s = []
    sum = 0
    for e in stations:
        if e in names:
            s.append(stations[e]['temp'])
    for i in range(len(s)):
        sum += s[i]
    avg =sum/len(s)
    return avg
# --------------------------------------------------
# 6330371221 (28.74) 208 (2021-03-28 18:04)

def approx_match(stations, name):
    a = []
    k = ''
    c = name.split()
    for i in range(len(c)):
        k +=c[i]
    s = k.upper()
    for i in stations.keys():
        if s in i:
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    x = []
    for i in stations.keys():
        x.append([(stations[i]['temp']),i])
    n = sorted(x)
    w = []
    for i in range(K):
            w.append((n[i])[1])
    return w
def top_k_max_temp_stations(stations, K):
    x = []
    for i in stations.keys():
        x.append([(stations[i]['temp']),i])
    n = sorted(x)[::-1]
    w = []
    for i in range(K):
            w.append((n[i])[1])
    return w
def peak_stations(stations):
    a = []
    b = []
    c = []
    for i in stations.keys():
        a.append([stations[i]['lat'],i])
    n = sorted(a)
    b.append((n[0])[1])
    b.append((n[len(n)-1])[1])
    for i in stations.keys():
        c.append([stations[i]['long'],i])
    s = sorted(c)
    b.append((s[0])[1])
    b.append((s[len(n)-1])[1])
    return b
def k_nearby_stations(stations, main_station, K):
    z = []
    e = []
    for i in stations.keys():
        lat1 = stations[i]['lat']
        lat2 = stations[main_station]['lat']
        long1 = stations[i]['long']
        long2 = stations[main_station]['long']
        n = distance(lat1,long1,lat2,long2)
        z.append([n,i])
    a = z
    k = sorted(a)
    for i in range(K):
        e.append((k[i+1])[1])
    return e
def average_temp(stations, names):
    k = 0
    for i in names:
        k += float(stations[i]['temp'])
    a = k/len(names)
    return a

# --------------------------------------------------
# 6330372921 (30) 209 (2021-03-29 22:23)

def approx_match(stations, name):
    name = name.replace(' ','')
    name = name.upper()
    ans = []
    for e in stations:
        if name in e.replace(' ','').upper():
            ans.append(e)
    return ans
def top_k_min_temp_stations(stations, K):
    temp = [] #[temp,ชื่อจังหวัด]
    for e in stations:
        temp.append([stations[e]['temp'],e])
    temp.sort()
    ans = []
    for i in range(K):
        ans.append(temp[i][1])
    return ans
def top_k_max_temp_stations(stations, K):
    temp = [] #[temp,ชื่อจังหวัด]
    for e in stations:
        temp.append([(-1)*stations[e]['temp'],e])
    temp.sort()
    ans = []
    for i in range(K):
        ans.append(temp[i][1])
    return ans
def peak_stations(stations):
    lat = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
    long = []
    for e in stations:
        long.append([stations[e]['long'],e])
    lat.sort()
    long.sort()
    ans = [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return ans
def k_nearby_stations(stations, main_station, K):
    a = stations[main_station]
    lat1 = a['lat']
    long1 = a['long']
    dist = []
    ans = []
    for e in stations:
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        dist.append([distance(lat1, long1, lat2, long2), e])
    dist.sort()
    dist = dist[1:]
    if len(dist) >= K:
        for i in range(K):
            ans.append(dist[i][1])
    else:
        for e in dist:
            ans.append(e[1])
    return ans
def average_temp(stations, names):
    sum = 0
    for e in names:
        sum += stations[e]['temp']
    average = sum/len(names)
    return average




# --------------------------------------------------
# 6330374121 (30) 210 (2021-03-27 01:08)

def approx_match(stations, name):
    def eraseSpaceAndBigger(word):
        word = word.upper()
        word2 = ''
        for e in word:
            if e != ' ':
                word2 += e
        return word2
    findWord = eraseSpaceAndBigger(name)
    li = []
    for e in stations:
        if findWord in eraseSpaceAndBigger(e):
            li.append(e)
    return li
def top_k_min_temp_stations(stations, K):
    li = []
    for key in stations:
        li.append([stations[key]['temp'],key])
    li.sort()
    li2 = []
    for e in li[:K]:
        li2.append(e[1])
    return li2
def top_k_max_temp_stations(stations, K):
    li = []
    for key in stations:
        li.append([-stations[key]['temp'],key])
    li.sort()
    li2 = []
    for e in li[:K]:
        li2.append(e[1])
    return li2
def peak_stations(stations):
    li_lat = []
    for key in stations:
        li_lat.append([stations[key]['lat'],key])
    li_lat.sort()
    lat_min = li_lat[0][1]
    lat_max = li_lat[-1][1]
    li_long = []
    for key in stations:
        li_long.append([stations[key]['long'],key])
    li_long.sort()
    long_min = li_long[0][1]
    long_max = li_long[-1][1]
    return [lat_min, lat_max, long_min, long_max]
def k_nearby_stations(stations, main_station, K):
    li = []
    for key in stations:
        d = distance(stations[main_station]['lat'], stations[main_station]['long'], stations[key]['lat'], stations[key]['long'])
        li.append([d, key])
    li.sort()
    li2 = []
    for e in li[1:K+1]:
        li2.append(e[1])
    return li2
def average_temp(stations, names):
    s = 0
    for e in names:
        s += stations[e]['temp']
    return s/(len(names))

# --------------------------------------------------
# 6330375821 (22.74) 211 (2021-03-29 23:31)

def approx_match(stations, name):
    name = name.upper().replace(" ","")
    a,b='',[]

    for co in range(len(name)):
        a = a+name[co]
    for co in stations:
        if a in co.upper().replace(" ",""):
            b.append(co)
    return b
def top_k_min_temp_stations(stations, K):
    T1 = []
    for co in stations:
        T1.append([stations[co]['temp'],co])
    T2 = [T1[1] for T1 in sorted(T1,reverse=False)]
    return T2[:K]
def top_k_max_temp_stations(stations, K):
    T1 = []
    for co in stations:
        T1.append([stations[co]['temp'],co])
    T2 = [T1[1] for T1 in sorted(T1,reverse=True)]
    return T2[:K]
def peak_stations(stations):
    Lat1,Long1 = [],[]

    for co in stations:
        Lat1.append([stations[co]['lat'],co])
        Long1.append([stations[co]['long'],co])
    Lat2 = [Lat1[1] for Lat1 in sorted(Lat1)]
    Long2 = [Long1[1] for Long1 in sorted(Long1)]
    Coordinates = [Lat2[0],Lat2[-1],Long2[0],Long2[-1]]
    return Coordinates
def k_nearby_stations(stations, main_station, K):
    a,b=[],''

    N = main_station.upper()
    for co in range(len(N)):
        b=b+N[co]
    D1 = []
    for co in stations:
        D1.append([Distance(stations[a]['lat'],stations[a]['long'], stations[co]['lat'],stations[co]['long']),co])
    D2 = [D1[1] for D1 in sorted(D1)]
    return D2[1:K+1]
def average_temp(stations, names):
    Avr = []
    for co in names:
        Avr.append(stations[co]['temp'])
    avr_temp = sum(Avr)/len(names)
    return avr_temp

# --------------------------------------------------
# 6330376421 (29.6) 212 (2021-03-26 21:40)

def approx_match(stations, name):
    a=[]
    for i in stations:
        if ''.join(name.upper().split()) in ''.join(i.upper().split()):
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort()
    e=[]
    for i in range(min(K,len(stations))):
        e.append(a[i][1])
    return e
def top_k_max_temp_stations(stations, K):
    a=[]
    for i in stations:
        a.append([-stations[i]['temp'],i])
    a.sort()
    e=[]
    for i in range(min(K,len(stations))):
        e.append(a[i][1])
    return e
def peak_stations(stations):
    import math
    lowest_lat,lowest_long=math.inf,math.inf
    highest_lat,highest_long=-math.inf,-math.inf
    for i in stations:
        if lowest_lat>stations[i]['lat']:
            lowest_lat=stations[i]['lat']
            lowest_lat1=i
        if highest_lat<stations[i]['lat']:
            highest_lat=stations[i]['lat']
            highest_lat1=i
        if lowest_long>stations[i]['long']:
            lowest_long=stations[i]['long']
            lowest_long1=i
        if highest_long<stations[i]['long']:
            highest_long=stations[i]['long']
            highest_long1=i

    return lowest_lat1,highest_lat1,lowest_long1,highest_long1
def k_nearby_stations(stations, main_station, K):
    a=[]
    for i in stations:
        a.append([distance(stations[main_station.upper()]['lat'],stations[main_station.upper()]['long'], stations[i]['lat'], stations[i]['long']),i])
    a.sort()
    e=[]
    for i in range(min(K+1,len(stations))):
        e.append(a[i][1])
    return e[1:]
def average_temp(stations, names):
    a=0
    for i in names:
        a+=stations[i]['temp']
    return a/len(names)

# --------------------------------------------------
# 6330377021 (30) 213 (2021-03-29 19:54)

def approx_match(stations, name):
    name = remove_space(name)
    name = name.upper()
    key = []
    for k in stations.keys():
        key.append(k)
    sta = []
    for e in key:
        k = remove_space(e)
        sta.append(k)
    result = []
    for i in range(len(sta)):
        if name in sta[i]:
            result.append(key[i])
    return result
def top_k_min_temp_stations(stations, K):
    value = []
    for v in stations.values():
        value.append(v['temp'])
    key = []
    for k in stations.keys():
        key.append(k)
    vk = []
    for i in range(len(value)):
        vk.append([value[i],key[i]])
    vk.sort()
    result = []
    for i in range(K):
        result.append(vk[i][1])
    return result
def top_k_max_temp_stations(stations, K):
    value = []
    for v in stations.values():
        value.append(v['temp'])
    key = []
    for k in stations.keys():
        key.append(k)
    v_k = []
    for i in range(len(value)):
        v_k.append([-value[i],key[i]])
    v_k.sort()
    result = []
    for i in range(K):
        result.append(v_k[i][1])
    return result
def peak_stations(stations):
    vk_lat,vk_long = vk_latlong(stations)
    vk_lat.sort()
    vk_long.sort()
    result = [vk_lat[0][1],vk_lat[-1][1],vk_long[0][1],vk_long[-1][1]]
    return result
def k_nearby_stations(stations, main_station, K):
    x = []
    lat = []
    long = []
    for v in stations.values():
        lat.append(v['lat'])
        long.append(v['long'])
    key = []
    for k in stations.keys():
        k = remove_space(k)
        k = k.upper()
        key.append(k)
    kv_latlong = []
    for i in range(len(lat)):
        kv_latlong.append([key[i],lat[i],long[i]])
    main_station = remove_space(main_station)
    for i in range(len(kv_latlong)):
        if main_station == kv_latlong[i][0]:
            lat1 = kv_latlong[i][1]
            long1 = kv_latlong[i][2]
            break
    vk_lat,vk_long = vk_latlong(stations)
    lat2 = []
    long2 = []
    for e in vk_lat:
        lat2.append(e[0])
    for e in vk_long:
        long2.append(e[0])
    for i in range(len(lat2)):
        d = distance(lat1, long1, lat2[i], long2[i])
        x.append([d,vk_lat[i][1]])
    x.sort()
    x = x[1:]
    result = []
    for i in range(K):
        result.append(x[i][1])
    return result
def average_temp(stations, names):
    summarize = 0
    for i in range(len(names)):
        summarize += stations[names[i]]['temp']
    avg = summarize/len(names)
    return avg
# --------------------------------------------------
def remove_space(name):
    n = ""
    for e in name:
        if e == " ":
            pass
        else:
            n += e
    return n.upper()
def vk_latlong(stations):
    lat = []
    long = []
    for v in stations.values():
        lat.append(v['lat'])
        long.append(v['long'])
    key = []
    for k in stations.keys():
        key.append(k)
    vk_lat = []
    for i in range(len(lat)):
        vk_lat.append([lat[i],key[i]])

    vk_long = []
    for i in range(len(long)):
        vk_long.append([long[i],key[i]])
    return [vk_lat,vk_long]
# 6330378721 (30) 214 (2021-03-27 16:29)

def approx_match(stations, name):

    name = name.upper().split()
    name = ''.join(name)
    a =[]
    for k in stations:
        e = k.split()
        e = ''.join(e)
        if name in e:
            a.append(k)

    return a
def top_k_min_temp_stations(stations, K):

    a = []
    b = []
    for c in stations:
        e = stations[c]['temp']
        b.append(e)
        b.append(c)
        a.append(b)
        b = []
    a.sort()
    top_min = []
    if K >= len(stations):
        K = len(stations)
    for i in range(K):
        top_min.append(a[i][1])
    return top_min
def top_k_max_temp_stations(stations, K):

    a = []
    b = []
    for c in stations:
        e = stations[c]['temp']
        b.append(e)
        b.append(c)
        a.append(b)
        b = []
    if K >= len(stations):
        K = len(stations)
    top_max = []
    sorted_a = []
    same_temp = []
    a.sort()
    a.reverse()
    for i in range(len(stations)):
        if i == len(stations)-1:
            sorted_a.append(a[i])
            for k in range(len(same_temp)):
                sorted_a.append(same_temp[k])
            same_temp = []
            break
        if a[i][0] == a[i+1][0]:
            same_temp.append(a[i])
        else:
            same_temp.reverse()
            sorted_a.append(a[i])
            for k in range(len(same_temp)):
                sorted_a.append(same_temp[k])
            same_temp = []
    for i in range(K):
        top_max.append(sorted_a[i][1])

    return top_max
def peak_stations(stations):

    latitude = []
    longtitude = []
    b = []
    j = []
    list_o_peak = []
    for c in stations:
        e = stations[c]['lat']
        f = stations[c]['long']
        b.append(e)
        b.append(c)
        j.append(f)
        j.append(c)
        latitude.append(b)
        longtitude.append(j)
        b = []
        j = []
    longtitude.sort()
    latitude.sort()
    list_o_peak.append(latitude[0][1])
    list_o_peak.append(latitude[-1][1])
    list_o_peak.append(longtitude[0][1])
    list_o_peak.append(longtitude[-1][1])

    return list_o_peak
def k_nearby_stations(stations, main_station, K):

    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    list_o_dis = []
    b = []
    K_nearby = []
    if K >= len(stations):
        K = len(stations)
    for a in stations:
        if a != main_station:
            lat_st = stations[a]['lat']
            long_st = stations[a]['long']
            b.append(distance(lat_main,long_main,lat_st,long_st))
            b.append(a)
            list_o_dis.append(b)
            b = []
    list_o_dis.sort()
    for i in range(K):
        K_nearby.append(list_o_dis[i][1])

    return K_nearby
def average_temp(stations, names):

    n = len(names)
    sigma_t = 0
    for i in range(n):
        sigma_t += stations[names[i]]['temp']
    avg_temp = sigma_t/n

    return avg_temp

# --------------------------------------------------
# 6330379321 (28.74) 215 (2021-03-27 21:38)

def approx_match(stations, name):

    name = name.lower()
    name = name.split()
    name = ''.join(name)
    result=[]
    for i in stations :
        j= i.lower().split()
        j= ''.join(j)
        if name in j :
            result.append(i)
    return result
def top_k_min_temp_stations(stations, K):

    Temp=[]
    for key in stations :
         T = stations[key]['temp']
         Temp.append([T,key])
    Temp.sort()
    result = []
    for i in Temp :
        result.append(i[1])
    return result[:K]
def top_k_max_temp_stations(stations, K):

    Temp=[]
    for key in stations :
         T = stations[key]['temp']
         Temp.append([T,key])
    Temp.sort(reverse = True)
    result = []
    for i in Temp :
        result.append(i[1])
    return result[:K]
def peak_stations(stations):

    lat = []
    long = []
    for key in stations :
        lat.append([stations[key]['lat'],key])
        long.append([stations[key]['long'],key])
    lat.sort()
    long.sort()
    result = [(lat[0])[1],(lat[-1])[1],(long[0])[1],(long[-1])[1]]
    return result
def k_nearby_stations(stations, main_station, K):


    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    d = []
    for key in stations :
        lat2 = (stations[key])['lat']
        long2 = (stations[key])['long']
        d.append([distance(lat1, long1, lat2, long2),key])
    d.sort()
    result = []
    for i in d :
        result.append(i[1])
    return result[1:K+1]
def average_temp(stations, names):

    T = 0
    for key in names :
        T += stations[key]['temp']
    avg = T/len(names)
    return avg


# --------------------------------------------------
# 6330380921 (30) 216 (2021-03-29 17:32)

def approx_match(stations, name):
    a=[]
    b=name.upper().strip().split()
    con_name=''
    for e in b:
        con_name+=e

    for i in stations:
        i_split=i.split()
        checkname=''
        for k in i_split:
            checkname+=k
        if con_name in checkname and con_name not in a:
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K): #notes กลับมาแก้ กรณี อุณหภูมิเท่ากันแล้วเรียงตัวอักษรด้วย เพราะยังไม่ได้เพิ่ม
    a=[]
    for i in stations:
        if i in stations:
            a.append([stations[i]['temp'],i])
    b=sorted(a)
    temp=[]
    c0=0
    while c0<K:
        temp.append(b[c0][1])
        c0+=1
    return temp
def top_k_max_temp_stations(stations, K): #notes กลับมาแก้ กรณี อุณหภูมิเท่ากันแล้วเรียงตัวอักษรด้วย เพราะยังไม่ได้เพิ่ม
    a=[]
    for i in stations:
        if i in stations:
            a.append([-stations[i]['temp'],i])
    a.sort()
    temp=[]
    c1=0
    while c1<K:
        temp.append(a[c1][1])
        c1+=1

    return temp
def peak_stations(stations):
    lat=[]
    long=[]
    for i in stations:
        if i in stations:
            lat.append([stations[i]['lat'],i])
            long.append([stations[i]['long'],i])
    lat.sort()
    long.sort()
    b=[min(lat)[1],max(lat)[1],min(long)[1],max(long)[1]]
    return b
def k_nearby_stations(stations, main_station, K):
    a=[]
    if main_station in stations:
        main_lat=stations[main_station]['lat']
        main_long=stations[main_station]['long']
    else:
        return []
    for i in stations:
        if i in stations:
            a.append([stations[i]['lat'],stations[i]['long'],i])
    dis_list=[]
    for e in a:
        if e[2] != main_station:
            dis_list.append([distance(e[0],e[1],main_lat,main_long),e[2]])
    dis_list.sort()
    c=0
    s=[]
    while c<K:
        s.append(dis_list[c][1])
        c+=1
    return s
    #distance(lat1, long1, lat2, long2)
def average_temp(stations, names):
    a=[]
    for i in names:
        if i in stations:
            a.append([stations[i]['temp'],i])
    sum_temp=0
    b=[]
    for t in a:
       if t[1] in stations:
           sum_temp+=t[0]
    return sum_temp/len(names)
# --------------------------------------------------
# 6330381521 (30) 217 (2021-03-29 22:05)

def approx_match(stations, name):

    new_name = ""
    new_name2 = []
    for i_i_i in name :

        if i_i_i != " " :
            new_name += str(i_i_i)

    new_name = new_name.upper()


    for station in stations.keys() :

        station_name = ""

        for data_ee in station :

            if data_ee != " " :
                station_name += data_ee


        station_name = station_name.upper()

        if new_name in station_name :

            new_name2.append(station)


    return new_name2
def top_k_min_temp_stations(stations, K):

    temp_station = []

    name_station = []

    for temp_data in stations :

        temp_station += [[stations[temp_data]["temp"] , temp_data]]



    for list_name in sorted(temp_station)[0:K] :

        name_station += [list_name[1]]



    return name_station
def top_k_max_temp_stations(stations, K):

    temp_station = []

    name_station = []

    for temp_data in stations :

        temp_station += [[-stations[temp_data]["temp"] , temp_data]]

    name_station = []


    for list_name in sorted(temp_station)[0:K] :

        name_station += [list_name[1]]



    return name_station
def peak_stations(stations):

    a_A_a_A = list(stations.keys())

    minimum_longitude = min(a_A_a_A , key = lambda e : stations[e]["long"])

    maximum_longitude = max(a_A_a_A , key = lambda e : stations[e]["long"])

    minimum_latitude = min(a_A_a_A , key = lambda e : stations[e]["lat"])

    maximum_latitude = max(a_A_a_A , key = lambda e : stations[e]["lat"])



    peak_temperature_station = [minimum_latitude,maximum_latitude,minimum_longitude,maximum_longitude]



    return peak_temperature_station
def k_nearby_stations(stations, main_station, K):

    listname_station = []

    sort_station = []

    longitude = stations[main_station]["long"]

    latitude = stations[main_station]["lat"]


    for number_of_stations in stations :

        listname_station += [[distance(latitude , longitude , stations[number_of_stations]["lat"] , stations[number_of_stations]["long"]) , number_of_stations]]


    for i_i_i_i in sorted(listname_station) :

        sort_station += [i_i_i_i[1]]


    return sort_station[1 : K+1]
def average_temp(stations, names):

    temperature_average = 0

    for list_station_name in names :

        temperature_average += stations[list_station_name]["temp"]

    temperature_average = temperature_average / (len(names))



    return temperature_average


# --------------------------------------------------
# 6330382121 (30) 218 (2021-03-28 17:23)

def approx_match(stations, name):
    list1 = []
    name = name.upper()
    name = name.replace(' ', '')
    for i in stations:
        if name in i:
            list1.append(i)

    return list1
def top_k_min_temp_stations(stations, K):
    list2 =[]
    info = {}
    key = []
    for i, j in stations.items():
        info.update({i:j['temp']})

    temp = sorted(info.values())
    sorted_dict = {}
    for k in temp:
        for l in sorted(info.keys()):
            if info[l] == k:
                sorted_dict[l] = info[l]
                key.append(l)
                info.pop(l)
                break

    for a in range(K):
        if a <= len(key) - 1:
            list2.append(key[a])
        else:
            break


    return list2
def top_k_max_temp_stations(stations, K):
    list2 =[]
    info = {}
    key = []
    for i, j in stations.items():
        info.update({i:j['temp']})

    temp = sorted(info.values(), reverse = True)

    for k in temp:
        for l in sorted(info.keys()):
            if info[l] == k:

                key.append(l)
                info.pop(l)
                break

    for a in range(K):
        if a <= len(key) - 1:
            list2.append(key[a])
        else:
            break


    return list2
def peak_stations(stations):
    list3 = []
    lat = {}
    long = {}
    for i, j in stations.items():
        lat.update({i:j['lat']})
    for i, j in stations.items():
        long.update({i:j['long']})
    lat_min = min(lat.values())
    for k in sorted(lat.keys()):
        if lat[k] == lat_min:
            list3.append(k)

    lat_max = max(lat.values())
    for k in sorted(lat.keys()):
        if lat[k] == lat_max:
            list3.append(k)

    long_min = min(long.values())
    for k in sorted(long.keys()):
        if long[k] == long_min:
            list3.append(k)

    long_max = max(long.values())
    for k in sorted(long.keys()):
        if long[k] == long_max:
            list3.append(k)

    return list3
def k_nearby_stations(stations, main_station, K):
    list4 = []
    lat = {}
    long = {}
    dist = {}
    for i, j in stations.items():
        lat.update({i:j['lat']})
    for i, j in stations.items():
        long.update({i:j['long']})
    for i in stations.keys():
        dist[i] = distance(lat[main_station], long[main_station], lat[i], long[i])
    dist.pop(main_station)
    key = []
    for i in sorted(dist.values()):
        for j in sorted(dist.keys()):
            if dist[j] == i:
                key.append(j)
                dist.pop(j)

    for a in range(K):
        if a <= len(key) - 1:
            list4.append(key[a])
        else:
            break

    return list4
def average_temp(stations, names):
    temp = []
    for i in names:
        temp.append(stations[i]['temp'])
    sum0 = 0
    for i in temp:
        sum0 += i
    avg = sum0 / len(temp)
    return avg


# --------------------------------------------------
# 6330384421 (30) 219 (2021-03-29 17:25)

def approx_match(stations, name):
    d=[]
    s=''
    q=''
    name=name.upper()
    if name.strip()=='':return ''
    for i in range(len(name)):
        if name[i]!=' ':s+=name[i]
    for i in stations:
        for w in range(len(i)):
            if i[w]!=' ':q+=i[w]
        if s in q.upper():d.append(i)
        q=''
    return d
def top_k_min_temp_stations(stations, K):
    s=[]
    for i in stations:
        s.append([stations[i]['temp'],i])
    s.sort()
    s=s[:K]
    for i in range(len(s)):
        s[i]=s[i][1]
    return s
def top_k_max_temp_stations(stations, K):
    s=[]
    for i in stations:
        s.append([-stations[i]['temp'],i])
    s.sort()
    s=s[:K]
    for i in range(len(s)):
        s[i]=s[i][1]
    return s
def peak_stations(stations):
    s=[]
    for i in stations:
        s.append([stations[i]['lat'],i])
    s.sort()
    s=s[0]
    s=s[1]
    s1=[]
    for i in stations:
        s1.append([-stations[i]['lat'],i])
    s1.sort()
    s1=s1[0]
    s1=s1[1]
    l=[]
    for i in stations:
        l.append([stations[i]['long'],i])
    l.sort()
    l=l[0]
    l=l[1]
    l1=[]
    for i in stations:
        l1.append([-stations[i]['long'],i])
    l1.sort()
    l1=l1[0]
    l1=l1[1]
    t=[s]+[s1]+[l]+[l1]
    return t
def k_nearby_stations(stations, main_station, K):
    s=[]
    for i in stations:
        if i!=main_station:s.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'], stations[main_station]['long']),i])
    s.sort()
    s=s[:K]
    for i in range(len(s)):
        s[i]=s[i][1]
    return s
def average_temp(stations, names):
    total=0
    l=len(names)
    for i in names:
        total+=stations[i]['temp']
    return total/l
# --------------------------------------------------
# 6330386721 (0) 220 (2021-03-28 20:47)

def approx_match(stations, name):
    date, nofs, dofs = read_weather_data()
    stations = dofs
    a = []
    b = ''
    c = []
    n = name.upper()
    for e in n:
        if not 'A' <= e <= 'Z':
            n = n.replace(e,'')
        elif 'A' <= e <= 'Z':
            b += e
    for e in stations:
        a.append(e)
    for e in stations:
        if b in e:
            c.append(e)
    return c
def top_k_min_temp_stations(stations, K):
    date, nofs, dofs = read_weather_data()
    stations = dofs
    a = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort()
    b = []
    for e in a:
        b.append(e[1])
    return b[0:K]
def top_k_max_temp_stations(stations, K):
    date, nofs, dofs = read_weather_data()
    stations = dofs
    a = []
    for e in stations:
        a.append([stations[e]['temp'],e])
    a.sort(reverse = True)
    b = []
    for e in a:
        b.append(e[1])
    return b[0:K]
def peak_stations(stations):
    date, nofs, dofs = read_weather_data()
    stations = dofs
    a = []
    for e in stations:
        a.append([stations[e]['lat'],e])
    a.sort()
    b = []
    b.append(a[0][1])
    b.append(a[-1][1])
    c = []
    for e in stations:
        c.append([stations[e]['long'],e])
    c.sort()
    b.append(c[0][1])
    b.append(c[-1][1])
    return b
def k_nearby_stations(stations, main_station, K):
    date, nofs, dofs = read_weather_data()
    stations = dofs
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    a = []
    for e in stations:
        b = distance(lat1, long1, stations[e]['lat'], stations[e]['long'])
        if b != 0:
            a.append([b,e])
    a.sort()
    b = []
    for e in a:
        b.append(e[1])
    return b[0:K]
def average_temp(stations, names):
    date, nofs, dofs = read_weather_data()
    stations = dofs
    t = 0
    for e in names:
        t += stations[e]['temp']
    return t/len(names)
# --------------------------------------------------
# 6330387321 (30) 221 (2021-03-29 00:12)

def approx_match(stations, name):
    a = []
    for i in range(len(name)):
        if 'a' <= name[i] <= 'z' or 'A' <= name[i] <= 'Z' :
            b = name[i].upper()
            a.append(b)
        else:
            pass
    c = ''.join(a)
    d = []
    for j in stations:
        if c in j:
            d.append(j)
        else:
            pass
    return d
def top_k_min_temp_stations(stations, K):
    a = []
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort()
    b = []
    for j in range(K):
        b.append(a[j][1])
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    for i in stations:
        a.append([-stations[i]['temp'],i])
    a.sort()
    b = []
    for j in range(K):
        b.append(a[j][1])
    return b
def peak_stations(stations):
    c = []
    a = []
    for i in stations:
        a.append([stations[i]['lat'],i])
    a.sort()
    c.append(a[0][1])
    c.append(a[-1][1])
    b = []
    for j in stations:
        b.append([stations[j]['long'],j])
    b.sort()
    c.append(b[0][1])
    c.append(b[-1][1])
    return c
def k_nearby_stations(stations, main_station, K):
    a = []
    for i in stations:
        if i != main_station:
            d = distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long'])
            a.append([d,i])
    a.sort()
    b = []
    for j in range(K):
        b.append(a[j][1])
    return b
def average_temp(stations, names):
    a = 0
    for i in names:
        a += stations[i]['temp']
    b = a/len(names)
    return b
# --------------------------------------------------
# 6330388021 (30) 222 (2021-03-28 00:42)

def approx_match(stations, name):
    a=[]
    s=''
    for i in name:
        if i != ' ':
            s+=i.upper()
    for i in stations :
        if s in i.upper():
            a+=[i]
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    b=[]
    for i in stations :
        a+=[[stations[i]['temp'],i.upper(),i]]
    a.sort()
    a=a[0:int(K)]
    for i in a :
        b+=[i[2]]
    return b
def top_k_max_temp_stations(stations, K):
    a=[]
    b=[]
    for i in stations :
        a+=[[-stations[i]['temp'],i.upper(),i]]
    a.sort()
    a=a[0:int(K)]
    for i in a :
        b+=[i[2]]
    return b
def peak_stations(stations):
    a=[]
    b=[]
    d=[]
    for i in stations :
        a+=[[stations[i]['lat'],i]]
    for i in stations :
        b+=[[stations[i]['long'],i]]
    c=[min(a),max(a),min(b),max(b)]
    for i in c :
        d+=[i[1]]
    return d
def k_nearby_stations(stations, main_station, K):
    a=[]
    b=[]
    for i in stations:
        a+=[[distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i.upper(),i]]
    a.sort()
    a=a[1:int(K)+1]
    for i in a :
        b+=[i[2]]
    return b
def average_temp(stations, names):
    a=0
    for i in names:
        a+=stations[i]['temp']
    a=a/len(names)
    return a
# --------------------------------------------------
# 6330389621 (29.6) 223 (2021-03-29 13:50)

def approx_match(stations, name):
    b=[]
    for i in range(len(name)):
        if 'a'<= name[i] <='z' or 'A'<= name[i] <='Z':
            a0 = name[i].upper()
            b.append(a0)
    c = "".join(b)
    d=[]
    for e in stations:
        if c in e:
            d.append(e)
    return d
def top_k_min_temp_stations(stations, K):
    list_min=[]
    for e in stations:
        list_min+=[[stations[e]["temp"],e]]
    list_min.sort()
    v=[]
    for i in range(len(list_min)):
        v.append(list_min[i][1])
    minn=v[:K]
    return minn
def top_k_max_temp_stations(stations, K):
    list_max=[]
    for e in stations:
        list_max+=[[stations[e]["temp"],e]]
    b=[]
    for [a1,a2] in list_max:
        b.append([-a1,a2])
    b.sort()
    h=[]
    for i in range(len(b)):
        h.append(b[i][1])
    maxx=h[:K]
    return maxx
def peak_stations(stations):
    lat_minn=[]
    for e in stations:
        lat_minn+=[[stations[e]["lat"],e]]
    lat_minn.sort()
    lat_min=lat_minn[0][1]

    long_minn=[]
    for e in stations:
        long_minn+=[[stations[e]["long"],e]]
    long_minn.sort()
    long_min=long_minn[0][1]

    lat_maxx=[]
    for e in stations:
        lat_maxx+=[[stations[e]["lat"],e]]
    maxx_lat=[]
    for [a1,a2] in lat_maxx:
        maxx_lat.append([-a1,a2])
    maxx_lat.sort()
    h=[]
    for i in range(len(maxx_lat)):
        h.append(maxx_lat[i][1])
    lat_max=h[0]

    long_maxx=[]
    for e in stations:
        long_maxx+=[[stations[e]["long"],e]]
    maxx_long=[]
    for [a1,a2] in long_maxx:
        maxx_long.append([-a1,a2])
    maxx_long.sort()
    h=[]
    for i in range(len(maxx_long)):
        h.append(maxx_long[i][1])
    long_max=h[0]

    return lat_min,lat_max,long_min,long_max
def k_nearby_stations(stations, main_station, K):
    for e in stations:
        if main_station==e:
            lat1=stations[e]["lat"]
            long1=stations[e]["long"]
            break
    d=[]
    for k in stations:
        lat2=stations[k]["lat"]
        long2=stations[k]["long"]
        d+=[[distance(lat1, long1, lat2, long2),k]]
    d.sort()
    g=[]
    for i in range(len(d)):
        g.append(d[i][1])
    show=g[1:K+1]
    return show
def average_temp(stations, names):
    n=0
    summ=0
    for e in names:
        summ+=stations[e]["temp"]
        n+=1
    average=summ/n
    return average


# --------------------------------------------------
# 6330391821 (30) 224 (2021-03-28 14:16)

def approx_match(stations, name):
    name = name.upper()
    x = ""
    for e in range(len(name)):
        if name[e].isalpha() == True:
            x += name[e]
    y = []
    for i in stations:
        if x in i.upper():
            y.append(i)
    return y
def top_k_min_temp_stations(stations, K):
    if K > len(stations):
        K = len(stations)
    d = []
    for e in stations:
        d.append([stations[e]['temp'],e])
    d.sort()
    Top_temp = []
    for i in range(K):
        Top_temp.append(d[i][1])
    return Top_temp
def top_k_max_temp_stations(stations, K):
    if K > len(stations):
        K = len(stations)
    d = []
    for e in stations:
        d.append([-stations[e]['temp'],e])
    d.sort()
    Top_temp = []
    for i in range(K):
        Top_temp.append(d[i][1])
    return Top_temp
def peak_stations(stations):
    lat = {}
    long = {}
    for e in stations:
        lat[stations[e]['lat']] = e
        long[stations[e]['long']] = e
    return [lat[min(lat)],lat[max(lat)],long[min(long)],long[max(long)]]
def k_nearby_stations(stations, main_station, K):
    if K > len(stations)-1:
        K = len(stations)-1
    s = {}
    y = []
    for e in stations:
        if e != main_station:
            x = distance(stations[e]['lat'],stations[e]['long'],stations[main_station]['lat'],\
                       stations[main_station]['long'])
            s[x] = e
            y.append(x)
    y.sort()
    nearby = []
    for i in range(K):
        nearby.append(s[y[i]])
    return nearby
def average_temp(stations, names):
    c = 0
    for e in names:
        c += stations[e]['temp']
    c /= len(names)
    return c

# --------------------------------------------------
# 6330392421 (12) 225 (2021-03-28 01:54)

def approx_match(stations, name):
    checker = ''
    name = name.upper()
    list_of_station_with_checker = []
    for e in name:
        if 'A' <= e <= 'Z':
            checker += e
    for e in stations:
        if checker in e:
            list_of_station_with_checker.append(e)
    return list_of_station_with_checker
def top_k_min_temp_stations(stations, K):
    temp_for_each_station = list_of_temp
    list_of_min_temp_station = []
    list_of_min_temp = []
    if K > len(stations):
        K = len(stations)
        while len(list_of_min_temp_station) != K:
            i = temp_for_each_station.index(min(temp_for_each_station))
            the_min = name_for_search[i]
            list_of_min_temp_station.append(the_min)
            temp_for_each_station.remove(min(temp_for_each_station))
            name_for_search.remove(the_min)
    else:
        while len(list_of_min_temp_station) != K+1:
            i = temp_for_each_station.index(min(temp_for_each_station))
            the_min = name_for_search[i]
            list_of_min_temp_station.append(the_min)
            list_of_min_temp.append(min(temp_for_each_station))
            temp_for_each_station.remove(min(temp_for_each_station))
            name_for_search.remove(the_min)
        if list_of_min_temp[K-1] == list_of_min_temp[K]:
            if list_of_min_temp_station[K-1] < list_of_min_temp_station[K]:
                list_of_min_temp_station.remove(list_of_min_temp_station[K])
            else:
                list_of_min_temp_station.remove(list_of_min_temp_station[K-1])
        else:
            list_of_min_temp_station = list_of_min_temp_station[:K:]
    return list_of_min_temp_station
def top_k_max_temp_stations(stations, K):
    temp_for_each_station = list_of_temp
    list_of_max_temp_station = []
    list_of_max_temp = []
    if K > len(stations):
        K = len(stations)
        while len(list_of_max_temp_station) != K:
            i = temp_for_each_station.index(max(temp_for_each_station))
            the_max = name_for_search[i]
            list_of_max_temp_station.append(the_max)
            temp_for_each_station.remove(max(temp_for_each_station))
            name_for_search.remove(the_max)
    else:
        while len(list_of_max_temp_station) != K+1:
            i = temp_for_each_station.index(max(temp_for_each_station))
            the_max = name_for_search[i]
            list_of_max_temp_station.append(the_max)
            list_of_max_temp.append(max(temp_for_each_station))
            temp_for_each_station.remove(max(temp_for_each_station))
            name_for_search.remove(the_max)
        if list_of_max_temp[K-1] == list_of_max_temp[K]:
            if list_of_max_temp_station[K-1] < list_of_max_temp_station[K]:
                list_of_max_temp_station.remove(list_of_max_temp_station[K])
            else:
                list_of_max_temp_station.remove(list_of_max_temp_station[K-1])
        else:
            list_of_max_temp_station = list_of_max_temp_station[:K:]
    return list_of_max_temp_station
def peak_stations(stations):
    list_of_peak=[]
    lat_min = list_of_lat.index(min(list_of_lat))
    lat_max = list_of_lat.index(max(list_of_lat))
    long_min = list_of_long.index(min(list_of_long))
    long_max = list_of_long.index(max(list_of_long))
    list_of_peak.append(name_for_search[lat_min])
    list_of_peak.append(name_for_search[lat_max])
    list_of_peak.append(name_for_search[long_min])
    list_of_peak.append(name_for_search[long_max])
    return list_of_peak
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    list_of_distance = []
    list_of_nearby_station = []
    list_of_nearby = []
    for e in name_for_search:
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        list_of_distance.append(distance(lat1, long1, lat2, long2))
    if K > len(stations):
        K = len(stations)
        while len(list_of_nearby) != K+2:
            i = list_of_distance.index(min(list_of_distance))
            the_nearby = name_for_search[i]
            list_of_nearby_station.append(the_nearby)
            list_of_distance.remove(min(list_of_distance))
            name_for_search.remove(the_nearby)

    else:
        while len(list_of_nearby) != K+2:
            i = list_of_distance.index(min(list_of_distance))
            the_nearby = name_for_search[i]
            list_of_nearby_station.append(the_nearby)
            list_of_nearby.append(min(list_of_distance))
            list_of_distance.remove(min(list_of_distance))
            name_for_search.remove(the_nearby)
        if list_of_nearby[K] == list_of_nearby[K+1]:
            if list_of_nearby_station[K] < list_of_nearby_station[K+1]:
                list_of_nearby_station.remove(list_of_nearby_station[K+1])
            else:
                    list_of_nearby_station.remove(list_of_nearby_station[K])
        else:
            list_of_nearby_station = list_of_nearby_station[1:K+15:]
    return list_of_nearby_station
def average_temp(stations, names):
    sum = 0
    for e in names:
        sum += stations[e]['temp']
    return sum/len(names)
# --------------------------------------------------
# 6330393021 (28.74) 226 (2021-03-29 17:23)

def approx_match(stations, name):
    n=[]
    name=namefix(name)
    for a in stations:
        if name.upper() in a:
            n.append(a)

    return n
def top_k_min_temp_stations(stations, K):
    a=[]
    x=[]
    for k,v in stations.items():
        a.append((v['temp'],k))
    a.sort()
    b=a[:K]
    for k in b:
        x.append(k[1])
    return x
def top_k_max_temp_stations(stations, K):
    a=[]
    x=[]
    for k,v in stations.items():
        a.append((v['temp'],k))
    a.sort()
    b=a[len(a)-K:]
    b = b[::-1]
    for k in b:
        x.append(k[1])
    return x
def peak_stations(stations):
    a=[]
    b=[]
    x=[]
    for k,v in stations.items():
        a.append((v['lat'],k))
    a.sort()


    x.append(a[0][1])
    x.append(a[-1][1])
    for k,v in stations.items():
        b.append((v['long'],k))
    b.sort()
    x.append(b[0][1])
    x.append(b[-1][1])

    return x
def k_nearby_stations(stations, main_station, K):
    a=[]
    x=[]
    lat2=stations[main_station]['lat']
    long2=stations[main_station]['long']
    for k,v in stations.items():
        if k==main_station:
            continue
        a.append((distance(v['lat'], v['long'], lat2, long2),k))
    a.sort()
    b=a[:K]
    for k in b:
        x.append(k[1])
    return x
def average_temp(stations, names):
    a=0
    for x in names :
        a+=(stations[x]['temp'])
    return a/len(names)




# --------------------------------------------------
def namefix(name):
    a=''
    for x in name:
        if x!=' ' :
            a+=x
    return a
# 6330395321 (30) 227 (2021-03-29 22:57)

def approx_match(stations, name):
    lisname = []
    stanee = ''
    for e in name.upper():
        if e == ' ':
            pass
        else :
            stanee += e
    for e in stations:
        if stanee in e:
            lisname.append(e)
        else :
            pass
    return lisname
def top_k_min_temp_stations(stations, K):
    pro = []
    sta = []
    for name in stations:
        pro.append([stations[name]['temp'] ,name])
    pro.sort()
    for i in range(K):
        if i == len(stations):
            break
        else:
            sta.append(pro[i][1])
    return sta
def top_k_max_temp_stations(stations, K):
    pro = []
    sta = []
    for name in stations:
        pro.append([-stations[name]['temp'] ,name])
    pro.sort()
    for i in range(K):
        if i == len(stations):
            break
        else:
            sta.append(pro[i][1])
    return sta
def peak_stations(stations):
    toon = [[stations[key]['lat'],key] for key in stations]
    tern = [[stations[key]['long'],key] for key in stations]
    toon.sort()
    tern.sort()
    return [toon[0][1],toon[-1][1],tern[0][1],tern[-1][1]]
def k_nearby_stations(stations, main_station, K):
    longlist = []
    longi = []
    lati = []
    upmain = main_station.upper()
    for key in stations:
        if key != upmain:
            lati.append([stations[key]['lat'],key])
            longi.append([stations[key]['long'],key])
    for i in range(len(lati)):
        x = distance(lati[i][0],longi[i][0],stations[upmain]['lat'],stations[upmain]['long'])
        longlist.append([x,lati[i][1]])
    longlist= sorted(longlist)[:K]
    near = [e[1] for e in (longlist)]
    return near
def average_temp(stations, names):
    j = 0
    t = 0
    if names == []:
        return 0
    for province in names:
        if province in stations:
            t += 1
            j += stations[province]['temp']
    return j / t

# --------------------------------------------------
# 6330396021 (28.74) 228 (2021-03-29 02:25)

def approx_match(stations, name):
    a = ""
    for i in name:
        if i not in a:
            a += i.strip()
    name_true = a.upper()
    list_stations = []
    for i in stations:
        if name_true in i:
            list_stations.append(i)
    return list_stations
def top_k_min_temp_stations(stations, K):
    stations_temp = {}
    for i in stations:
        stations_temp[i] = stations[i]['temp']
    list_reverse_stations_temp = []
    for i in stations_temp:
        list_reverse_stations_temp.append([stations_temp[i],i])
    list_reverse_stations_temp.sort()
    list_min_stations = []

    if K <= len(list_reverse_stations_temp):
        for e in range(K):
            list_min_stations.append(list_reverse_stations_temp[e][1])
    return list_min_stations
def top_k_max_temp_stations(stations, K):
    stations_temp = {}
    for i in stations:
        stations_temp[i] = stations[i]['temp']
    list_reverse_stations_temp = []
    for i in stations_temp:
        list_reverse_stations_temp.append([stations_temp[i],i])
    list_reverse_stations_temp.sort(reverse=True)
    list_max_stations = []
    if K <= len(list_reverse_stations_temp):
        for e in range(K):
            list_max_stations.append(list_reverse_stations_temp[e][1])
    return list_max_stations
def peak_stations(stations):
    K = 1
    stations_lat = {}
    for i in stations:
        stations_lat[i] = stations[i]['lat']

    list_reverse_stations_lat = []
    for i in stations_lat:
        list_reverse_stations_lat.append([stations_lat[i],i])

    list_reverse_stations_lat.sort()
    list_min_stations_lat = []
    if K <= len(list_reverse_stations_lat):
        for e in range(K):
            list_min_stations_lat.append(list_reverse_stations_lat[e][1])
    else :
        for e in range(len(list_reverse_stations_lat)):
            list_min_stations_lat.append(list_reverse_stations_lat[e][1])

    list_reverse_stations_lat.sort(reverse=True)
    list_max_stations_lat = []
    if K <= len(list_reverse_stations_lat):
        for e in range(K):
            list_max_stations_lat.append(list_reverse_stations_lat[e][1])
    else :
        for e in range(len(list_reverse_stations_lat)):
            list_max_stations_lat.append(list_reverse_stations_lat[e][1])


    stations_long = {}
    for i in stations:
        stations_long[i] = stations[i]['long']

    list_reverse_stations_long = []
    for i in stations_long:
        list_reverse_stations_long.append([stations_long[i],i])

    list_reverse_stations_long.sort()
    list_min_stations_long = []
    if K <= len(list_reverse_stations_long):
        for e in range(K):
            list_min_stations_long.append(list_reverse_stations_long[e][1])
    else :
        for e in range(len(list_reverse_stations_long)):
            list_min_stations_long.append(list_reverse_stations_long[e][1])

    list_reverse_stations_long.sort(reverse=True)
    list_max_stations_long = []
    if K <= len(list_reverse_stations_long):
        for e in range(K):
            list_max_stations_long.append(list_reverse_stations_long[e][1])
    else :
        for e in range(len(list_reverse_stations_long)):
            list_max_stations_long.append(list_reverse_stations_long[e][1])

    return list_min_stations_lat + list_max_stations_lat + list_min_stations_long + list_max_stations_long
def k_nearby_stations(stations, main_station, K):
    lat1_main_station = stations[main_station.upper()]['lat']
    long1_main_station = stations[main_station.upper()]['long']

    list_stations_lat_long = []
    for i in stations:
        list_stations_lat_long.append([i,stations[i]['lat'],stations[i]['long']])

    list_all_distance = []
    for i in range(len(list_stations_lat_long)):
        distance_from_a_to_main_station = distance(lat1_main_station, long1_main_station, list_stations_lat_long[i][1], list_stations_lat_long[i][2])
        list_all_distance.append([distance_from_a_to_main_station, list_stations_lat_long[i][0]])
    list_all_distance.sort()

    list_name_of_min_distance_stations = []
    if K <= len(list_all_distance):
        for e in range(1,K+1):
            list_name_of_min_distance_stations.append(list_all_distance[e][1])
    else :
        for e in range(1,len(list_all_distance)):
            list_name_of_min_distance_stations.append(list_all_distance[e][1])
    return list_name_of_min_distance_stations
def average_temp(stations, names):
    list_stations_temp = []
    for i in stations:
        list_stations_temp.append([i,stations[i]['temp']])
    sum_temp = 0
    num_station = 0
    for e in range(len(list_stations_temp)):
        if list_stations_temp[e][0] in names :
            sum_temp += list_stations_temp[e][1]
            num_station += 1
    average_temp = sum_temp/num_station
    return average_temp



# --------------------------------------------------
# 6330397621 (22) 229 (2021-03-29 23:46)

def approx_match(stations, name):
    new_name = ""
    for e in name:
        if e!= " ":
            new_name += e.upper()

    listOfStation = []
    originalNameStation = []
    for station in stations:
        stationName = ""
        for char in station:
            if char != " ":
                stationName += char.upper()
        listOfStation.append(stationName)
        originalNameStation.append(station)

    output = []
    for station in listOfStation:
        if new_name in station:
            output.append(originalNameStation[listOfStation.index(station)])

    return output
def top_k_min_temp_stations(stations, K):
    if K == 0:
        return []
    temperature = []
    for station in stations:
        temperature.append([stations[station]['temp'],station])
    temperature.sort()

    output = []
    for i in range(K):
        if i < len(temperature):
            stationName = temperature[i][1]
            output.append(stationName)
    return output
def top_k_max_temp_stations(stations, K):
    if K == 0:
        return []
    temperature = []
    for station in stations:
        temperature.append([-stations[station]['temp'],station])
    temperature.sort()

    output = []
    for i in range(K):
        if i < len(temperature):
            stationName = temperature[i][1]
            output.append(stationName)
    return output
def peak_stations(stations):
    latitudeList = []
    longgitudeList = []
    for station in stations:
        latitudeList.append([stations[station]['lat'],station])
        longgitudeList.append([stations[station]['long'],station])

    latitudeList.sort()
    longgitudeList.sort()
    output = []
    output.append(latitudeList[0][1])
    output.append(latitudeList[0][-1])
    output.append(longgitudeList[0][1])
    output.append(longgitudeList[0][-1])
    return output
def k_nearby_stations(stations, main_station, K):
    if K == 0:
        return []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    pairDistance = []
    for station in stations:
        if station != main_station:
            lat2 = stations[station]['lat']
            long2 = stations[station]['lat']
            pairDistance.append([distance(lat1,long1,lat2,long2),station])
    pairDistance.sort()

    output = []
    for i in range(K):
        if i < len(pairDistance):
            stationName = pairDistance[i][1]
            output.append(stationName)
    return output
def average_temp(stations, names):
    sumTemp = 0
    for stationName in names:
        sumTemp += stations[stationName]['temp']
    return sumTemp / len(names)


# --------------------------------------------------
# 6330398221 (30) 230 (2021-03-28 23:38)

def approx_match(stations, name):
    name=name.upper()
    name_s=name.replace(' ','')
    stations_pick=[]
    for e in stations:
        if name_s in e.replace(' ','').upper():
            stations_pick.append(e)
    return stations_pick
def top_k_min_temp_stations(stations, K):
    stations_t=[]
    for i in stations:
        stations_t.append([stations[i]['temp'],i])
    stations_t.sort()
    stations_min=[]
    if K<=len(stations_t):
        for n in range(K):
            stations_min.append(stations_t[n][1])
    else:
        for n in range(len(stations_t)):
            stations_min.append(stations_t[n][1])

    return stations_min
def top_k_max_temp_stations(stations, K):
    stations_t=[]
    for i in stations:
        stations_t.append([-stations[i]['temp'],i])
    stations_t.sort()
    stations_max=[]
    if K<=len(stations_t):
        for n in range(K):
            stations_max.append(stations_t[n][1])
    else:
        for n in range(len(stations_t)):
            stations_max.append(stations_t[n][1])
    return stations_max
def peak_stations(stations):
    stations_lat=[]
    stations_long=[]
    stations_peak=[]
    for i in stations:
        stations_lat.append([stations[i]['lat'],i])
        stations_long.append([stations[i]['long'],i])
    stations_lat.sort()
    stations_long.sort()
    stations_peak.append(stations_lat[0][1])
    stations_peak.append(stations_lat[-1][1])
    stations_peak.append(stations_long[0][1])
    stations_peak.append(stations_long[-1][1])
    return stations_peak
def k_nearby_stations(stations, main_station, K):
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    near_station=[]
    for i in stations:
        if i!=main_station:
            lat2=stations[i]['lat']
            long2=stations[i]['long']
            d=distance(lat1,long1,lat2,long2)
            near_station.append([d,i])
    near_station.sort()
    nearby=[]
    if len(near_station)>=K:
        for e in range(K):
            nearby.append(near_station[e][1])
    else:
        for e in near_station:
            nearby.append(e[1])
    return nearby
def average_temp(stations, names):
    temp=0
    for i in names:
        temp+=stations[i]['temp']
    avr_temp=temp/len(names)
    return avr_temp




# --------------------------------------------------
# 6330399921 (28.74) 231 (2021-03-29 21:47)

def approx_match(stations, name):
    name=('').join(name.split()).lower()
    lis=[]
    for i in stations:
        if name in ('').join(i.lower().split()):
            lis.append(i)
    return lis
def top_k_min_temp_stations(stations,K):
    lis=[]
    lis1=[]
    for i in stations:
        lis.append([stations[i]['temp'],i])
    lis.sort()
    for i in lis[:K]:
        lis1.append(i[1])
    return lis1
def top_k_max_temp_stations(stations, K):
    lis=[]
    lis1=[]
    for i in stations:
        lis.append([stations[i]['temp'],i])
    lis.sort()
    for i in lis[::-1][:K]:
        lis1.append(i[1])
    return lis1
def peak_stations(stations):
    lis_lat=[]
    lis_long=[]
    for i in stations:
        lis_lat.append([stations[i]['lat'],i])
        lis_long.append([stations[i]['long'],i])
    lis_lat.sort()
    lis_long.sort()
    return [lis_lat[0][1],lis_lat[-1][1],lis_long[0][1],lis_long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lis=[]
    lis1=[]
    for i in stations:
        lis.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i])
    lis.sort()
    for i in lis[1:K+1]:
        lis1.append(i[1])
    return lis1
def average_temp(stations, names):
    x=0
    for i in names:
        x+=stations[i]['temp']
    return x/len(names)
# --------------------------------------------------
# 6330400821 (24.72) 232 (2021-03-28 17:11)

def approx_match(stations, name):
    G = []
    for i in stations :
        if name.lower() in i.lower() :
            G.append(i)
    return G
def top_k_min_temp_stations(stations, K):
    L = []
    G = []
    for i in stations:
        L.append([stations[i]['temp'], i])
    L.sort()
    print(L)
    for i in range(len(L)):
        z = L[i]
        G.append(z[1])
    print(len(L))
    return G[0:K]
def top_k_max_temp_stations(stations, K):
    L = []
    G = []
    for i in stations:
        L.append([stations[i]['temp'], i])
    L.sort()
    for i in range(len(L)):
        z = L[i]
        G.append(z[1])
    return G[-1:-K-1:-1]
def peak_stations(stations):
   Max = []
   Max_1 = []
   Max_name = []
   Max_name_1 = []
   for i in stations :
       Max.append([stations[i]['lat'],i])
   Max.sort()
   for i in stations :
       Max_1.append([stations[i]['long'],i])
   Max_1.sort()
   for i in range(len(Max)) :
      z = Max[i]
      Max_name.append(z[1])
   for i in range(len(Max)) :
      z_1 = Max_1[i]
      Max_name_1.append(z_1[1])
   return [Max_name[0],Max_name[-1],Max_name_1[0],Max_name_1[-1]]
def k_nearby_stations(stations, main_station, K):
    stations_list = []
    distance_list = []
    latijod_0 = stations[main_station]['lat']
    longtijod_0 = stations[main_station]['long']
    for i in stations :
           latijod_n = stations[i]['lat']
           longtijod_n = stations[i]['long']
           z = distance(latijod_0,longtijod_0,latijod_n,longtijod_n)
           distance_list.append([z,i])
    distance_list.sort()
    for i in range(1,K+1) :
        if len(distance_list) <= K :
            e = 1
            while e < len(distance_list) :
                stations_list.append(distance_list[e][1])
                e += 1
        else :
            stations_list.append(distance_list[i][1])
    print(distance_list)
    print(len(distance_list),K)
    print(stations_list)
    return stations_list
def average_temp(stations, names):
    s = 0
    for i in names :
        y = stations[i]
        s += y['temp']
    return s/len(names)


# --------------------------------------------------
# 6330401421 (28.74) 233 (2021-03-29 18:54)

def approx_match(stations, name):
    st = []
    N = ''
    for i in name:
        if i != ' ':
            N += i
    N = N.upper()
    for i in stations:
        s = ''
        for e in i:
            if e != ' ':
                s += e
        if N in s:
            st.append(i)
    return st
def top_k_min_temp_stations(stations, K):
    all_s = []
    for i in stations:
        i_s = []
        i_s.append(stations[i]['temp'])
        i_s.append(i)
        all_s.append(i_s)
    all_s.sort()
    min_s = all_s[:int(K)]
    min_K_s = []
    for e in range(len(min_s)):
        min_K_s.append(min_s[e][1])

    return min_K_s
def top_k_max_temp_stations(stations, K):
    all_s = []
    for i in stations:
        i_s = []
        i_s.append(stations[i]['temp'])
        i_s.append(i)
        all_s.append(i_s)
    all_s.sort(reverse = True)
    max_s = all_s[:int(K)]
    max_K_s = []
    for e in range(len(max_s)):
        max_K_s.append(max_s[e][1])

    return max_K_s
def peak_stations(stations):
    all_long_peak = []
    all_lat_peak = []
    for i in stations:
        lat_st_i = []
        lat_st_i.append(stations[i]['lat'])
        lat_st_i.append(i)
        long_st_i = []
        long_st_i.append(stations[i]['long'])
        long_st_i.append(i)
        all_lat_peak.append(lat_st_i)
        all_long_peak.append(long_st_i)
    all_lat_peak.sort()
    all_long_peak.sort()
    min_lat = all_lat_peak[0]
    max_lat = all_lat_peak[-1]
    min_long = all_long_peak[0]
    max_long = all_long_peak[-1]
    p_stations = [min_lat[1],max_lat[1],min_long[1],max_long[1]]

    return p_stations
def k_nearby_stations(stations, main_station, K):
    lat_m = stations[main_station]['lat']
    long_m = stations[main_station]['long']
    s_dist = []
    for i in stations:
        dist = []
        lat_i = stations[i]['lat']
        long_i = stations[i]['long']
        dist.append(distance(lat_m, long_m, lat_i, long_i))
        dist.append(i)
        s_dist.append(dist)
    s_dist.sort()
    near_K_dist = s_dist[1:int(K)+1]
    k_near_stations = []
    for i in range(len(near_K_dist)):
        k_near_stations.append(near_K_dist[i][1])


    return k_near_stations
def average_temp(stations, names):
    s = 0
    for n in stations:
        if n in names:
            s += (stations[n]['temp'])
    return s/len(names)



# --------------------------------------------------
# 6330402021 (24.72) 234 (2021-03-29 21:48)

def approx_match(stations, name):
    name = name.upper()
    match = []
    for sta in stations:
        if sta.find(name) != -1:
            match.append(sta)
    return match
def top_k_min_temp_stations(stations, K):
    x = []
    for i in stations:
        a = stations[i]["temp"]
        x.append([a,i])
    x.sort()
    if K > len(x):
        c = len(x)
    else:
        c = K
    z = []
    for i in range(c):
        z.append(x[i][1])
    return z
def top_k_max_temp_stations(stations, K):
    x = []
    for i in stations:
        a = stations[i]["temp"]
        x.append([a,i])
    x.sort(reverse = True)
    if K > len(x):
        c = len(x)
    else:
        c = K
    z = []
    for i in range(c):
        z.append(x[i][1])
    return z
def peak_stations(stations):
    x = []
    y = []
    z = []
    for i in stations:
        a = stations[i]["lat"]
        x.append([a,i])
    x.sort()
    z.append(x[0][1])
    z.append(x[-1][1])
    for i in stations:
        a = stations[i]["long"]
        y.append([a,i])
    y.sort()
    z.append(y[0][1])
    z.append(y[-1][1])
    return z
def k_nearby_stations(stations, main_station, K):
    info_main = stations[main_station]
    lat1 = info_main["lat"]
    long1 = info_main["long"]
    x = []
    for i in stations:
        lat2 = stations[i]["lat"]
        long2 = stations[i]["long"]
        d = distance(lat1, long1, lat2, long2)
        x.append([d,i])
    x.sort()
    if K > len(x):
        c = len(x)
    else:
        c = K
    z = []
    for i in range(1,c+1):
        z.append(x[i][1])
    return z
def average_temp(stations, names):
    temp = 0
    for i in names:
        temp += stations[i]["temp"]
    return temp/len(names)


# --------------------------------------------------
# 6330403721 (30) 235 (2021-03-28 23:33)

def approx_match(stations, name):


    name = name.upper()
    name = name.split()
    name = ''.join(name)

    sta = []
    for sm in stations:
        sta.append(sm.upper())

    sss = []
    for t in sta:
        sss.append(t)
    for i in range(len(sta)):
        sta[i] = sta[i].split()
        sta[i] = ''.join(sta[i])
        sta[i] = sta[i].upper()

    sta_name = []
    for i in range(len(sta)):
        if name in sta[i]:
            sta_name.append(sss[i])


    return sta_name
def top_k_min_temp_stations(stations, K):

    state = []
    for sta in stations:
        state += [[stations[sta]['temp'],sta]]
        state.sort()

    temp = []
    c = 0
    if K <= len(state):
        while c <= K-1:
            temp.append(state[c][1])
            c += 1
    else:
        while c <= len(state)-1:
            temp.append(state[c][1])
            c += 1

    return temp
def top_k_max_temp_stations(stations, K):

    state = []
    for sta in stations:
        state += [[-stations[sta]['temp'],sta]]
        state.sort()

    temp = []
    c = 0
    if K <= len(state):
        while c <= K-1:
            temp.append(state[c][1])
            c += 1
    else:
        while c <= len(state)-1:
            temp.append(state[c][1])
            c += 1

    return temp
def peak_stations(stations):

    stala = []
    for sta in stations:
        stala += [[stations[sta]['lat'],sta]]
        stala.sort()

    stalo = []
    for sta in stations:
        stalo += [[stations[sta]['long'],sta]]
        stalo.sort()

    lalo = []
    lalo.append(stala[0][1])
    lalo.append(stala[-1][1])
    lalo.append(stalo[0][1])
    lalo.append(stalo[-1][1])

    return lalo
def k_nearby_stations(stations, main_station, K):

    stan = {}
    if main_station in stations:
        for sta in stations:
            if sta != main_station:
                stan[sta] = stations[sta]

        dis = []
        for sta in stan:
            lat1 = stations[main_station]['lat']
            long1 = stations[main_station]['long']
            lat2 = stan[sta]['lat']
            long2 = stan[sta]['long']

            dis += [[distance(lat1, long1, lat2, long2),sta]]
            dis.sort()

        near = []
        c = 0

        if K <= len(dis):
            while c <= K-1:
                 near.append(dis[c][1])
                 c += 1
        else:
            for i in range(len(dis)):
                near.append(dis[i][1])

    else:
        dis = 'No main station'


    return near
def average_temp(stations, names):

    temp = []
    t_sum = 0
    for i in range (len(names)):
        for c in stations:
            if names[i] == c:
                temp.append(stations[c]['temp'])
                t_sum += stations[c]['temp']
    if len(temp) != 0:
        t_avg = t_sum/len(temp)
    else:
        t_avg = 'No Name in stations'

    return t_avg

# --------------------------------------------------
# 6330404321 (30) 236 (2021-03-29 13:58)

def approx_match(stations, search):
 normailized_search = search.upper().replace(' ', '')
 station_names = list(stations.keys())
 normalized_stations = [(idx, st.upper().replace(' ', '')) for (idx, st) in enumerate(station_names)]
 matches = [idx for (idx, st) in normalized_stations if (st.find(normailized_search) != -1)]
 return [station_names[idx] for idx in matches]
def top_k_min_temp_stations(stations, K):
 station_temps = [(data['temp'], name) for (name, data) in stations.items()]
 sorted_station_temps = sorted(station_temps)[:K]
 return [name for (temp, name) in sorted_station_temps]
def top_k_max_temp_stations(stations, K):
 station_neg_temps = [(-data['temp'], name) for (name, data) in stations.items()]
 sorted_station_neg_temps = sorted(station_neg_temps)[:K]
 return [name for (temp, name) in sorted_station_neg_temps]
def peak_stations(stations):
 station_lats = [(data['lat'], name) for (name, data) in stations.items()]
 (max_lat_lat, max_lat_name) = max(station_lats)
 (min_lat_lat, min_lat_name) = min(station_lats)
 station_lngs = [(data['long'], name) for (name, data) in stations.items()]
 (max_lng_lng, max_lng_name) = max(station_lngs)
 (min_lng_lng, min_lng_name) = min(station_lngs)
 return [min_lat_name, max_lat_name, min_lng_name, max_lng_name]
def k_nearby_stations(stations, main_station, K):
 main_station_data = stations[main_station]
 main_lat = main_station_data['lat']
 main_lng = main_station_data['long']
 station_cords = [((data['lat'], data['long']), name) for (name, data) in stations.items() if (name != main_station)]
 station_dists = [(distance(main_lat, main_lng, st_lat, st_lng), name) for ((st_lat, st_lng), name) in station_cords]
 sorted_station_dists = sorted(station_dists)[:K]
 return [name for (dist, name) in sorted_station_dists]
def average_temp(stations, names):
 selected_station_temps = [stations[name]['temp'] for name in names]
 return sum(selected_station_temps) / len(selected_station_temps)


# --------------------------------------------------
# 6330405021 (30) 237 (2021-03-29 23:05)

def approx_match(stations, name):
    l=[]
    name=name.upper().replace(' ','')
    for x in stations:
        if name in x.upper().replace(' ',''):
            l.append(x)
    return l
def top_k_min_temp_stations(stations, K):
    l=[]
    for x in stations:
        l.append([stations[x]['temp'],x])
    l.sort()
    return [x[1] for x in l[:K]]
def top_k_max_temp_stations(stations, K):
    l=[]
    for x in stations:
        l.append([-stations[x]['temp'],x])
    l.sort()
    return [x[1] for x in l[:K]]
def peak_stations(stations):
    lati,longi=[],[]
    for x in stations:
        lati.append([stations[x]['lat'],x])
        longi.append([stations[x]['long'],x])
    return [min(lati)[1],max(lati)[1],min(longi)[1],max(longi)[1]]
def k_nearby_stations(stations, main_station, K):
    lat0,long0,l=stations[main_station]['lat'],stations[main_station]['long'],[]

    for x in stations:
        lat,long=stations[x]['lat'],stations[x]['long']
        l.append([distance(lat,long,lat0,long0),x])
    return [x[1] for x in sorted(l)[1:K+1]]
def average_temp(stations, names):
    import statistics as s
    l=[]
    for x in names:
        l.append(stations[x]['temp'])
    return s.mean(l)

# --------------------------------------------------
# 6330406621 (24) 238 (2021-03-29 12:01)

def approx_match(stations, name):
    l = []
    name1 = "".join([i.upper() for i in name if i != " "])
    for j in stations:
        if name1 in "".join([k.upper() for k in j if k != " "]):
            l += [j]
    return l



#print(approx_match(stations0[2], 't  hani'))
def top_k_min_temp_stations(stations, K):
    tl = []
    ntl = []
    ltl = []
    tf = []
    tff = []
    for i in stations:
        tl += [[stations[i]['temp'], i]]
    tl.sort()
    #print(tl)
    target = []
    temp = []
    variable = tl[0][0]

    for i in range(len(tl)):

            if tl[i][0] == variable:
                temp.append(tl[i])
            else:
                target.append(temp)
                temp = [tl[i]]
                variable = tl[i][0]
    for j in target:
        j.sort(key = lambda v:v[1])
        for p in j:
            ntl += [p]
    #print(ntl)
    for t in ntl:
        tff += [t[1]]
    tf = tff[:K]
    return tf

#print(top_k_min_temp_stations(stations0[2], 15))
def top_k_max_temp_stations(stations, K):
    tl = []
    ntl = []
    ltl = []
    tf = []
    tff = []
    for i in stations:
        tl += [[stations[i]['temp'], i]]
    tl.sort()
    tl = tl[::-1]
    #print(tl)
    target = []
    temp = []
    variable = tl[0][0]

    for i in range(len(tl)):

            if tl[i][0] == variable:
                temp.append(tl[i])
            else:
                target.append(temp)
                temp = [tl[i]]
                variable = tl[i][0]
    for j in target:
        j.sort(key = lambda v:v[1])
        for p in j:
            ntl += [p]
    #print(ntl)
    for t in ntl:
        tff += [t[1]]
    tf = tff[:K]
    return tf

#print(top_k_max_temp_stations(stations0[2], 8))
def peak_stations(stations):
    x = []
    y = []
    for i in stations:
        x += [[(stations[i])["lat"], i]]
    x.sort()
    minlat = x[0][1]
    maxlat = x[-1][1]
    for j in stations:
        y += [[stations[j]["long"], j]]
    y.sort()
    minlong = y[0][1]
    maxlong = y[-1][1]
    allpeak = [minlat, maxlat, minlong, maxlong]
    return allpeak
#print(peak_stations(stations0[2]))
def k_nearby_stations(stations, main_station, K):
    a = []
    b = []
    for i in stations:
        a += [[distance(stations[i]["lat"], stations[i]["long"], stations[main_station]["lat"], stations[main_station]["long"]), i]]
    a.sort()
    dist = a[:K]
    for j in dist:
        b += [j[1]]
    near = b
    return near
#print(k_nearby_stations(stations, "MAE HONG SON", 5))
def average_temp(stations, names):
    tem = 0
    for i in names:
        tem += stations[i]["temp"]
    avg = tem/(len(names))
    return avg



# --------------------------------------------------
# 6330407221 (30) 239 (2021-03-26 19:06)

def approx_match(stations, name):
    x = ''
    n = name.upper()
    match = []
    for i in n :
        if 'A'<=i<='Z':
            x+=i
    for y in stations:
        if x in y:
            match.append(y)
    return(match)
def top_k_min_temp_stations(stations, K):
    new = []
    minn = []
    for i in stations:
        a = [stations[i]['temp'],i]
        new.append(a)
    new.sort()
    limit = len(new)
    if K <= limit :
        for y in range(K):
            get = str(new[y][1])
            minn.append(get)
    elif K > limit :
        for r in range(limit):
            get = str(new[r][1])
            minn.append(get)

    return minn
def top_k_max_temp_stations(stations, K):
    new = []
    maxx = []
    for i in stations:
        a = [(-1)*stations[i]['temp'],i]
        new.append(a)
    new.sort()
    limit = len(new)
    if K <= limit:
        for y in range(K):
            get = str(new[y][1])
            maxx.append(get)
    elif K > limit :
        for z in range(limit):
            get = str(new[z][1])
            maxx.append(get)
    return maxx
def peak_stations(stations):
    long = []
    for i in stations:
        a = [stations[i]['long'],i]
        long.append(a)
    long.sort()
    highestlong = long[-1][1]
    lowestlong = long[0][1]

    lat = []
    for i in stations:
        a = [stations[i]['lat'],i]
        lat.append(a)
    lat.sort()
    highestlat = lat[-1][1]
    lowestlat = lat[0][1]

    final = [lowestlat,highestlat,lowestlong,highestlong]
    return final
def k_nearby_stations(stations, main_station, K):
    check = []
    lat1 = stations[main_station.upper()]['lat']
    long1 = stations[main_station.upper()]['long']
    for i in stations:
        if i != main_station.upper():
            lat2 = stations[i]['lat']
            long2 = stations[i]['long']
            dis = distance(lat1, long1, lat2, long2)
            add = [float(dis),i]
            check.append(add)
    check.sort()
    final = []
    limit = len(check)
    if K<= limit :
        for y in range(K):
            final.append(check[y][1])
    elif K > limit :
        for z in range(limit):
            final.append(check[z][1])
    return final
def average_temp(stations, names):
    summ = 0
    amount = len(names)
    for i in names:
        if i in stations:
            add = stations[i]['temp']
            summ += add
    answer = summ/amount
    return answer





# --------------------------------------------------





# --------------------------------------------------
# 6330408921 (30) 240 (2021-03-27 01:33)

def approx_match(stations, name):
    new_name = ''
    ans = []
    if name == '':
        return []
    for s in name:
        if s == ' ':
            new_name += ''
        else:
            new_name += s.upper()
    for s in stations.keys():
        if new_name in s.upper().replace(' ', ''):
            ans.append(s)
    return ans
def top_k_min_temp_stations(stations, K):
    ans = []
    temp = {}
    for key in stations:
        temp[key] = stations[key]['temp']
    temp = {k: v for k, v in sorted(temp.items(), key=lambda item: item[0])}
    temp = {k: v for k, v in sorted(temp.items(), key=lambda item: item[1])}
    for s in temp.keys():
        ans.append(s)
    return ans[:K]
def top_k_max_temp_stations(stations, K):
    ans = []
    temp = {}
    for key in stations:
        temp[key] = stations[key]['temp']
    temp = {k: v for k, v in sorted(temp.items(), key=lambda item: item[0])}
    temp = {k: v for k, v in sorted(temp.items(), reverse=True, key=lambda item: item[1])}
    for s in temp.keys():
        ans.append(s)
    return ans[:K]
def peak_stations(stations):#กรณีเจอมากกว่า1ตัวยังไม่ชัวร์
    ans = []
    lat = {}
    lat_list = []
    long = {}
    long_list = []
    for key in stations:
        lat[key] = stations[key]['lat']
    for key in stations:
        long[key] = stations[key]['long']
    lat = {k: v for k, v in sorted(lat.items(), key=lambda item: item[0])}
    lat = {k: v for k, v in sorted(lat.items(), key=lambda item: item[1])}
    long = {k: v for k, v in sorted(long.items(), key=lambda item: item[0])}
    long = {k: v for k, v in sorted(long.items(), key=lambda item: item[1])}
    for s in lat.keys():
        lat_list.append(s)
    for s in long.keys():
        long_list.append(s)
    ans.append(lat_list[0])
    ans.append(lat_list[-1])
    ans.append(long_list[0])
    ans.append(long_list[-1])
    return ans
def k_nearby_stations(stations, main_station, K):
    ans = []
    dist = {}
    for key in stations:
        dist[key] = distance(stations[key]['lat'], stations[key]['long'], stations[main_station]['lat'], stations[main_station]['long'])
    dist = {k: v for k, v in sorted(dist.items(), key=lambda item: item[0])}
    dist = {k: v for k, v in sorted(dist.items(), key=lambda item: item[1])}
    for s in dist:
        ans.append(s)
    return ans[1:K+1]
def average_temp(stations, names):
    ans = 0
    for s in names:
        ans += stations[s]['temp']
    ans /= len(names)
    return ans

# --------------------------------------------------
# 6330409521 (30) 241 (2021-03-29 16:16)

def approx_match(stations, name):
    found_sta = []
    name1 = ''
    for i in range(len(name)):
        if not name[i] ==' ':
            name1 = name1 + name[i]
    for n in stations:
        n = n.lower()
        name1 = name1.lower()
        if name1 in n:
            n = n.upper()
            found_sta.append(n)
        else:
            pass
    return found_sta
def top_k_min_temp_stations(stations, K):
     if K >= len(stations):
        K = len(stations)
     else:
        pass
     interest_temp =[]
     for n in stations:
         temp = stations[n]['temp']
         interest_temp.append([(1)*(temp),n])
     interest_temp.sort()
     complete = []
     for i in range(K):
         complete.append(str(interest_temp[i][1]))

     return complete
def top_k_max_temp_stations(stations, K):
    if K >= len(stations):
        K = len(stations)
    else:
        pass
    interest_temp =[]
    for n in stations:
        temp = stations[n]['temp']
        interest_temp.append([(-1)*(temp),n])
    interest_temp.sort()
    complete = []
    for i in range(K):
        complete.append(str(interest_temp[i][1]))
    return complete
def peak_stations(stations):
    int_lat = []
    for n in stations:
        lat = stations[n]['lat']
        int_lat.append([-1*lat,n])
    int_lat.sort()
    max_lat = int_lat[0][1]
    min_lat = int_lat[-1][1]
    int_long = []
    for n in stations:
        lat = stations[n]['long']
        int_long.append([-1*lat,n])
    int_long.sort()
    max_long = int_long[0][1]
    min_long = int_long[-1][1]
    complete = []
    complete.append(str(min_lat))
    complete.append(str(max_lat))
    complete.append(str(min_long))
    complete.append(str(max_long))
    return complete
def k_nearby_stations(stations, main_station, K):
    if K > len(stations):
        K = len(stations)
    int_dist = []
    for n in stations:
        if n == main_station:
            pass
        else:
            lat1 = stations[main_station]['lat']
            lat2 = stations[n]['lat']
            long1 =stations[main_station]['long']
            long2 =stations[n]['long']
            s = distance(lat1,long1,lat2,long2)
            int_dist.append([abs(s),n])
    int_dist.sort()
    complete= []
    for i in range(K):
        complete.append(str(int_dist[i][1]))
    return complete
def average_temp(stations, names):
    temp_sum = 0
    for n in names:
        temp_n = stations[n]['temp']
        temp_sum += temp_n
    temp_avg = temp_sum/len(names)
    return temp_avg



# --------------------------------------------------
# 6330410021 (30) 242 (2021-03-27 20:43)

def approx_match(stations, name):
    c=[]
    name=name.upper()
    name1=''
    for i1 in name:
        if not i1 ==' ':
            name1+=i1

    for i in stations:
        i=i.upper()
        if name1 in i:
            c.append(i)

    return c
def top_k_min_temp_stations(stations, K):
    c=[]
    c1=[]
    for i in stations:
        if 'temp' in stations[i]:
            c.append([stations[i]['temp'],i])
    c.sort()
    for i in c:
        c1.append(i[1])
    c1=c1[:K]
    return c1
def top_k_max_temp_stations(stations, K):
    c=[]
    c1=[]
    for i in stations:
        if 'temp' in stations[i]:
            c.append([stations[i]['temp'],i])
    c=minus(c)
    c.sort()
    c=minus(c)
    for i in c:
        c1.append(i[1])
    c1=c1[:K]
    return c1
def peak_stations(stations):
    cla=[]
    clo=[]
    ans=[]
    for i in stations:
        if 'lat' in stations[i]:
            cla.append([stations[i]['lat'],i])
        if 'long' in stations[i]:
            clo.append([stations[i]['long'],i])
    cla.sort()
    clo.sort()
    ans.append(cla[0][1])
    ans.append(cla[-1][1])
    ans.append(clo[0][1])
    ans.append(clo[-1][1])
    return ans
def k_nearby_stations(stations, main_station, K):
    e=[]
    e1=[main_station,stations[main_station]['lat'],stations[main_station]['long']]
    klai=[]
    kla=[]
    for i in stations:
        if 'lat' in stations[i] and 'long' in stations[i]:
            e.append([i,stations[i]['lat'],stations[i]['long']])
    for i in e:
        klai.append([distance(e1[1], e1[2], i[1], i[2]),i[0]])
    klai.sort()
    for i in klai:
        kla.append(i[1])
    kla=kla[1:K+1]
    return kla
def average_temp(stations, names):
    e=0
    c=0
    for i in names:
        if 'temp' in stations[i]:
            e+=stations[i]['temp']
            c+=1
    if not c==0:
        e=e/c
    return e



# --------------------------------------------------
def minus(e):
    c=[]
    for i in e:
        c.append([-i[0],i[1]])
    return c
# 6330411721 (30) 243 (2021-03-28 23:16)

def approx_match(stations, name):
    name = name.upper()
    nameUp = ''
    if name == '':
        return []
    for i in range(len(name)):
        if 'A' <= name[i] <= 'Z':
            nameUp += name[i]
        elif name[i] == ' ':
            pass
        else:
            nameUp += ' '
    stationList = []
    for e in stations:
        if nameUp in e:
            stationList.append(e)
    return stationList
def top_k_min_temp_stations(stations, K):
    a = []
    for e in stations:
        temp = stations[e]['temp']
        a.append(temp)
    a.sort()
    if K>0:
        a = a[:K]
    else:
        return []
    num = []
    for i in range(len(a)):
        if a[i-1] == a[i]:
            pass
        else:
            num.append(a[i])
    if num == []:
        num.append(a[0])
    stationList = []
    for i in num:
        inum = []
        for e in stations:
            if stations[e]['temp'] == i:
                inum.append(e)
        inum.sort()
        for e in inum:
            stationList.append(e)
    return stationList[:K]
def top_k_max_temp_stations(stations, K):
    a = []
    for e in stations:
        temp = stations[e]['temp']
        a.append(temp)
    a.sort()
    a = a[-1::-1]
    if K>0:
        a = a[:K]
    else:
        return []
    num = []
    for i in range(len(a)):
        if a[i-1] == a[i]:
            pass
        else:
            num.append(a[i])
    if num == []:
        num.append(a[0])
    stationList = []
    for i in num:
        inum = []
        for e in stations:
            if stations[e]['temp'] == i:
                inum.append(e)
        inum.sort()
        for e in inum:
            stationList.append(e)
    return stationList[:K]
def peak_stations(stations):
    lat = []
    long = []
    for e in stations:
        lat.append(stations[e]['lat'])
        long.append(stations[e]['long'])
    lat.sort()
    long.sort()
    latmin = '' ; latmax ='' ; longmin = '' ; longmax = ''
    for e in stations:
        if stations[e]['lat'] == lat[0]:
            latmin = e
        if stations[e]['lat'] == lat[-1]:
            latmax = e
        if stations[e]['long'] == long[0]:
            longmin = e
        if stations[e]['long'] == long[-1]:
            longmax = e
    peak = [latmin,latmax,longmin,longmax]
    return peak
def k_nearby_stations(stations, main_station, K):
    latmain = stations[main_station]['lat']
    longmain = stations[main_station]['long']
    dislist = []
    disDic = {}
    for e in stations:
        dis = distance(latmain,longmain,stations[e]['lat'],stations[e]['long'])
        disDic[e] = dis
        dislist.append(dis)
    dislist.sort()
    neardis = dislist[1:K+1]
    nearstation = []
    for e in neardis:
        for st in disDic:
            if e == disDic[st]:
                nearstation.append(st)
    return nearstation[:K]
def average_temp(stations, names):
    tempall = []
    for i in range(len(names)):
        temp = stations[names[i]]['temp']
        tempall.append(temp)
    tempsum = 0
    for i in tempall:
        tempsum += i
    avg = tempsum/len(names)
    avg = round(avg,1)
    return avg



# --------------------------------------------------
# 6330412321 (30) 244 (2021-03-29 16:51)

def approx_match(stations, name):
    x = ''
    for e in name:
        if e == ' ':
            x +=''
        else:
            x += e

    x = x.upper()
    a = []
    b = []
    for key in stations:
        y = ''
        for e in key:
            if e ==' ':
                y+=''
            else:
                y+= e
        a.append(y.upper())
        b.append(key)
    c = []
    for i in range(len(a)):
        if x in a[i]:
            c.append(b[i])
    return c
def top_k_min_temp_stations(stations, K):
    a = []
    for key in stations:
        a.append([stations[key]['temp'],key])
        a.sort()
    b = []
    for e in a:
        b.append(e[1])
    c = b[0:K]
    return c
def top_k_max_temp_stations(stations, K):
    a = []
    for key in stations:
        a.append([-1*stations[key]['temp'],key])
        a.sort()
    b = []
    for e in a:
        b.append(e[1])
    c = b[0:K]
    return c
def peak_stations(stations):
    a = []
    for key in stations:
        a.append([stations[key]['lat'],key])
    b = min(a)[1]
    c = max(a)[1]
    i = []
    for key in stations:
        i.append([stations[key]['long'],key])
    j = min(i)[1]
    k = max(i)[1]
    d = [b,c,j,k]
    return d
def k_nearby_stations(stations, main_station, K):
    a = main_station.upper()
    c = []
    if a in stations:
        for key in stations:
            b = distance(stations[a]['lat'],stations[a]['long'],stations[key]['lat'],stations[key]['long'])
            c.append([b,key])
    c.sort()
    d = []
    for e in c:
        d.append(e[1])
    e = d[1:K+1]
    return e
def average_temp(stations, names):
    s = 0
    a = 1
    for e in names:
        s += stations[e]['temp']
        b = s/a
        a +=1
    return b



# --------------------------------------------------
# 6330413021 (30) 245 (2021-03-29 22:13)

def approx_match(stations, name):
    ans = []
    name = name.replace(' ','')
    for e in stations :
        a = e.replace(' ','')

        for i in range((len(a)-len(name)+1)*int(len(name) != 0)) :

            if a[i:i+len(name)].upper() == name.upper() :
                ans.append(e)
    return ans
def top_k_min_temp_stations(stations, K):
    ans = []
    for e in stations :
        ans.append([stations[e]['temp'],e])
    minlist = sorted(ans)
    return [minlist[i][1] for i in range(len(minlist[:K]))]
def top_k_max_temp_stations(stations, K):
    ans = []
    for e in stations :
        ans.append([-stations[e]['temp'],e])
    maxlist = sorted(ans)
    return   [maxlist[i][1] for i in range(len(maxlist[:K]))]
def peak_stations(stations):
    minla = ['',math.inf]
    maxla = ['',-math.inf]
    minlong = ['',math.inf]
    maxlong = ['',-math.inf]
    for e in stations :
        lat0  = stations[e]['lat']
        long0 = stations[e]['long']
        if lat0 < minla[1] :
           minla[0] = e
           minla[1] = stations[e]['lat']
        if lat0 > maxla[1] :
           maxla[0] = e
           maxla[1] = stations[e]['lat']
        if long0 < minlong[1] :
           minlong[0] = e
           minlong[1] = stations[e]['long']
        if long0 > maxlong[1] :
           maxlong[0] = e
           maxlong[1] = stations[e]['long']
    return [minla[0],maxla[0],minlong[0],maxlong[0]]
def k_nearby_stations(stations, main_station, K):
    namelist = []
    lats = stations[main_station]['lat']
    longs = stations[main_station]['long']
    for e in stations :
        namelist.append([e,distance(lats,longs,stations[e]['lat'],stations[e]['long'])])
    namelist.sort(key=lambda x:(x[1],x[0]))
    return [e[0] for e in namelist[1:K+1]]
def average_temp(stations, names):
    temp = 0
    for e in names :
        temp += stations[e]['temp']
    return temp/len(names)

# --------------------------------------------------
# 6330415221 (30) 246 (2021-03-29 21:52)

def approx_match(stations, name):
    names = name.upper()
    ex = ''
    for i in names :
        if i == ' ' :
            ex += ''
        else :
            ex += i

    Name = []
    for i in stations :
        a = ''
        for e in i :
            if e == ' ' :
                a += ''
            else :
                a += e
        if ex in a :
            Name.append(i)

    return Name
def top_k_min_temp_stations(stations, K):
    temps = []
    for i in stations :
        temp = stations[i]['temp']
        temps.append(temp)
    temps.sort()

    if K > len(temps) :
        temp_k = temps
    else :
        temp_k = temps[:K:1]

    def remove(t, r) :
        if r.count(t) > 1 :
            pp = [t]
            for i in range(len(r)) :
                if r[i] != t :
                    pp.append(r[i])
        else :
            pp = r
        return pp

    def remove_v2(t, r) :
        pp = []
        for i in range(len(r)) :
            if r[i] != t :
                pp.append(r[i])
        return pp

    for i in range(len(temp_k)) :
        if temp_k[i] == temp_k[-1] :
            break
        else :
            temp_k = remove(temp_k[i], temp_k)
    temp_k.sort()

    name_min_temp = []
    for e in temp_k :
        p = []
        for i in stations :
            if stations[i]['temp'] == e :
                p.append(i)
        if len(p) > 1 :
            u = []
            for i in range(len(p)) :
                u.append(min(p))
                p = remove_v2(min(p), p)
            for i in u :
                name_min_temp.append(i)
        else :
            name_min_temp.append(p[0])

    return name_min_temp
def top_k_max_temp_stations(stations, K):
    temps = []
    for i in stations :
        temp = -stations[i]['temp']
        temps.append(temp)
    temps.sort()

    if K > len(temps) :
        temp_k = temps
    else :
        temp_k = temps[:K:1]

    def remove(t, r) :
        if r.count(t) > 1 :
            pp = [t]
            for i in range(len(r)) :
                if r[i] != t :
                    pp.append(r[i])
        else :
            pp = r
        return pp

    def remove_v2(t, r) :
        pp = []
        for i in range(len(r)) :
            if r[i] != t :
                pp.append(r[i])
        return pp

    for i in range(len(temp_k)) :
        if temp_k[i] == temp_k[-1] :
            break
        else :
            temp_k = remove(temp_k[i], temp_k)
    temp_k.sort()

    name_max_temp = []
    for e in temp_k :
        p = []
        for i in stations :
            if -stations[i]['temp'] == e :
                p.append(i)
        if len(p) > 1 :
            u = []
            for i in range(len(p)) :
                u.append(min(p))
                p = remove_v2(min(p), p)
            for i in u :
                name_max_temp.append(i)
        else :
            name_max_temp.append(p[0])

    return name_max_temp
def peak_stations(stations):
    lats = []
    for i in stations :
        latitude = stations[i]['lat']
        lats.append(latitude)
    lats.sort()

    longs = []
    for i in stations :
        longitude = stations[i]['long']
        longs.append(longitude)
    longs.sort()

    name = []

    for i in stations :
        if stations[i]['lat'] == lats[0] :
            name.append(i)

    for i in stations :
        if stations[i]['lat'] == lats[-1] :
            name.append(i)

    for i in stations :
        if stations[i]['long'] == longs[0] :
            name.append(i)

    for i in stations :
        if stations[i]['long'] == longs[-1] :
            name.append(i)

    return name
def k_nearby_stations(stations, main_station, K):
    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']

    Distance = []
    for i in stations :
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        dist = distance(lat_main, long_main, lat2, long2)
        Distance.append(dist)
    Distance.sort()

    if K+1 > len(Distance) :
        distance_k = Distance[1::1]
    else :
        distance_k = Distance[1:K+1:1]

    def remove(t, r) :
        if r.count(t) > 1 :
            pp = [t]
            for i in range(len(r)) :
                if r[i] != t :
                    pp.append(r[i])
        else :
            pp = r
        return pp

    def remove_v2(t, r) :
        pp = []
        for i in range(len(r)) :
            if r[i] != t :
                pp.append(r[i])
        return pp

    for i in range(len(distance_k)) :
        if distance_k[i] == distance_k[-1] :
            break
        else :
            distance_k = remove(distance_k[i], distance_k)
    distance_k.sort()

    name = []
    for e in distance_k :
        p = []
        for i in stations :
            lat = stations[i]['lat']
            long = stations[i]['long']
            dist = distance(lat_main, long_main, lat, long)
            if dist == e :
                p.append(i)
        if len(p) > 1 :
            u = []
            for i in range(len(p)) :
                u.append(min(p))
                p = remove_v2(min(p), p)
            for i in u :
                name.append(i)
        else :
            name.append(p[0])

    return name
def average_temp(stations, names):
    temps = []
    for i in names :
        temp = stations[i]['temp']
        temps.append(temp)

    T = 0
    for i in temps :
        T += float(i)

    av_temp = T/len(temps)

    return av_temp

# --------------------------------------------------
# 6330416921 (30) 247 (2021-03-29 02:54)

def approx_match(stations, name):
    a=[]
    name2=''
    for e in name:
        if 'a'<= e <='z' or 'A'<= e <='Z':
            name2 += e.upper()



    for i in stations:
        if name2 in i:
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):

    a=[]
    for i in stations:
        a.append([ stations[i]['temp'] , i ])
    a.sort()
    b=[]
    for e in range(K):

        b.append(a[e][1])
    return b
def top_k_max_temp_stations(stations, K):

    a=[]
    for i in stations:
        b= stations[i]['temp'] *(-1)
        d=[b,i]
        a.append(d)

    a.sort()


    b=[]
    for e in range(K):

        b.append(a[e][1])
    return b
def peak_stations(stations):
    peak=[]
    a=[]
    for i in stations:
        a.append([ stations[i]['lat'] , i ])
    a.sort()
    peak.append(a[0][1])

    b=[]
    for i in stations:
        b.append([ -stations[i]['lat'] , i ])
    b.sort()
    peak.append(b[0][1])

    c=[]
    for i in stations:
        c.append([ stations[i]['long'] , i ])
    c.sort()
    peak.append(c[0][1])

    d=[]
    for i in stations:
        d.append([ -stations[i]['long'] , i ])
    d.sort()
    peak.append(d[0][1])
    return peak
def k_nearby_stations(stations, main_station, K):

    a=[]
    for i in stations:
        dis = distance(stations[main_station]['lat'], stations[main_station]['long'],stations[i]['lat'], stations[i]['long'])
        a.append([dis,i])

    a.sort()
    near=[]
    for e in range(1,K+1):
        near.append(a[e][1])

    return near
def average_temp(stations, names):
    sum1=0
    for i in names:
        sum1 += stations[i]['temp']

    avg=sum1/len(names)

    return avg
# --------------------------------------------------
# 6330417521 (30) 248 (2021-03-29 10:26)

def approx_match(stations, name):
    mat = []
    name = name.lower()
    n = name.split()
    n = ''.join(n)
    for e in stations:
        e_l = e.lower()
        st = e_l.split()
        st = ''.join(st)
        if n in st:
            mat.append(e)
    return(mat)
def top_k_min_temp_stations(stations, K):
    mi = []
    for e in stations:
        mi.append([stations[e]['temp'], e])
    mi.sort()
    if len(mi) <= K:
        ans = []
        for e in mi:
            ans.append(e[1])
    else:
        ans = []
        for i in range(K):
            ans.append(mi[i][1])
    return ans
def top_k_max_temp_stations(stations, K):
    ma = []
    for e in stations:
        ma.append([stations[e]['temp']*-1, e])
    ma.sort()
    if len(ma) <= K:
        ans = []
        for e in ma:
            ans.append(e[1])
    else:
        ans = []
        for i in range(K):
            ans.append(ma[i][1])
    return ans
def peak_stations(stations):
    for name in stations:
        break
    ma_la = name
    ma_lo = name
    mi_la = name
    mi_lo = name
    for e in stations:
        if stations[e]['lat'] > stations[ma_la]['lat']:
            ma_la = e
        if stations[e]['long'] > stations[ma_lo]['long']:
            ma_lo = e
        if stations[e]['lat'] < stations[mi_la]['lat']:
            mi_la = e
        if stations[e]['long'] < stations[mi_lo]['long']:
            mi_lo = e
    ans = [mi_la, ma_la, mi_lo, ma_lo]
    return ans
def k_nearby_stations(stations, main_station, K):
    nea = []
    for e in stations:
        if e != main_station:
            dis = distance(stations[e]['lat'], stations[e]['long'], stations[main_station]['lat'], stations[main_station]['long'])
            nea.append([dis, e])
    nea.sort()
    if len(nea) <= K:
        ans = []
        for e in nea:
            ans.append(e[1])
    else:
        ans = []
        for i in range(K):
            ans.append(nea[i][1])
    return ans
def average_temp(stations, names):
    su_tem = 0
    for e in names:
        su_tem += stations[e]['temp']
    aver = su_tem / len(names)
    return round(aver,1)

# --------------------------------------------------
# 6330418121 (30) 249 (2021-03-29 01:55)

def approx_match(stations, name):
    pattern = ""
    name = name.lower()
    for v in name :
        if "a" <= v <= "z" :
            pattern += v
    rlt = []
    for s_name in stations :
        if pattern in s_name.lower() :
            rlt.append(s_name)
    print(rlt)
    return rlt
def top_k_min_temp_stations(stations, K):
    data = []
    for x in stations :
        data.append([stations[x]["temp"],x])
    sortData = sorted(data)
    ans = [x[1] for x in sortData]
    return ans[:min(K,len(ans))]
def top_k_max_temp_stations(stations, K):
    data = [[-stations[x]["temp"],x] for x in stations]
    sortData = sorted(data)
    ans = [x[1] for x in sortData]
    return ans[:min(K,len(ans))]
def peak_stations(stations):
    #value = [[min],[max]]
    latitude = [[1e9,''],[-1e9,'']]
    longtitude = [[1e9,''],[-1e9,'']]
    for x in stations :
        if stations[x]['lat'] > latitude[1][0] :
            latitude[1][0] = stations[x]['lat']
            latitude[1][1] = x
        if stations[x]['long'] > longtitude[1][0] :
            longtitude[1][0] = stations[x]['long']
            longtitude[1][1] = x
        if stations[x]['lat'] < latitude[0][0] :
            latitude[0][0] = stations[x]['lat']
            latitude[0][1] = x
        if stations[x]['long'] < longtitude[0][0] :
            longtitude[0][0] = stations[x]['long']
            longtitude[0][1] = x
    return [latitude[0][1],latitude[1][1],longtitude[0][1],longtitude[1][1]]
def k_nearby_stations(stations, main_station, K):
    data = []
    for x in stations :
        st1 = stations[x]
        st2 = stations[main_station]
        dis = distance(st1["lat"],st1["long"],st2["lat"],st2["long"])
        if x != main_station :
            data.append([dis,x])
    sort_data = sorted(data)
    ans = [x[1] for x in sort_data]
    return ans[:min(K,len(ans))]
def average_temp(stations, names):
    total_temp = 0
    cnt = 0
    for station in stations :
        if station in names :
            total_temp += stations[station]['temp']
            cnt+=1
    avg = total_temp/cnt
    return avg

# --------------------------------------------------
# 6330420321 (30) 250 (2021-03-25 19:58)

def approx_match(stations, name):
    Found_station = set()
    query = name.replace(' ','')

    for i in stations.items() :
        if i[0].replace(' ','').lower().find(query.lower()) >= 0 :
            Found_station.add(i[0])

    return list(Found_station)
def top_k_min_temp_stations(stations, K):
    Found_station = []
    sta_item = list(stations.items())
    sta_item.sort()
    s = sorted(sta_item, key=lambda x: x[1]['temp'])
    s = s[:K]
    for i in s :
        Found_station.append(i[0])

    return Found_station
def top_k_max_temp_stations(stations, K):
    Found_station = []
    sta_item = list(stations.items())
    sta_item.sort()
    s = sorted(sta_item, key=lambda x: x[1]['temp'], reverse=True)
    s = s[:K]
    for i in s :
        Found_station.append(i[0])

    return Found_station
def peak_stations(stations):
    less_lat = min(stations, key= lambda x: stations[x]['lat'])
    most_lat = max(stations, key= lambda x: stations[x]['lat'])
    less_long = min(stations, key= lambda x: stations[x]['long'])
    most_long = max(stations, key= lambda x: stations[x]['long'])

    return [less_lat,most_lat,less_long,most_long]
def k_nearby_stations(stations, main_station, K):
    sta_item = list(stations.items())
    sta_item.sort()

    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    Distlist = []
    for i in stations :
        if i != main_station :
            lat_sta = stations[i]['lat']
            long_sta = stations[i]['long']

            Distlist.append([i,distance(lat_main,long_main,lat_sta,long_sta)])


    Distlist.sort(key= lambda x : x[1])
    Distlist = Distlist[:K:]
    Final_l = [sta[0] for sta in Distlist]
    return Final_l
def average_temp(stations, names):
    total_temp = 0
    for i in names :
        total_temp += stations[i]['temp']

    return total_temp / len(names)

# --------------------------------------------------
# 6330422621 (25.82) 251 (2021-03-28 16:27)

def approx_match(stations, name):
    a = []
    yum = []
    d = name.lower().split()
    name = "".join(d)
    for x in stations.keys():
        a.append(x)
    for i in range(len(a)):
        f = str(a[i]).lower()
        p1 = f.find(name[0])
        p2 = f.find(name[0],p1+1)
        p3 = f.find(name[0],p2+1)
        p4 = f.find(name[0],p3+1)
        p5 = f.find(name[0],p4+1)
        if f[p1:len(name)+p1] == name:
            yum.append(f.upper())
        elif f[p2:len(name)+p2] == name:
            yum.append(f.upper())
        elif f[p3:len(name)+p3] == name:
            yum.append(f.upper())
        elif f[p4:len(name)+p4] == name:
            yum.append(f.upper())
        elif f[p5:len(name)+p5] == name:
            yum.append(f.upper())
    return yum
def top_k_min_temp_stations(stations, K):
    b = []
    st = stations
    for x in st.keys():
        b.append(x)
    if K > len(b):
        K = len(b)
    mix_all_min = []
    y = []
    min_value = []

    for i in range(K):
        if  len(mix_all_min) < K:
            a = []
            p = 0
            value_temp = []
            for x in st.keys():
                a.append(x)
            for i in range(len(a)):
                value_temp.append(st[a[i]]['temp'])
            min_va = min(value_temp)
            for i in range(len(a)):
                if min_va == st[a[i]]['temp'] and len(min_value) < K:#14.3
                    x = a[i]#A Bc
                    y.append(st[x])
                    mix_all_min.append(x)
                    min_value.append(min_va)
                    if st[a[i]]['temp'] == min_value[p]:
                        mix_all_min.sort()
                        p += 1
                    st.pop(x)
    for i in range(len(y)):
        st[mix_all_min[i]] = y[i]
    return mix_all_min
def top_k_max_temp_stations(stations, K):
    b = []
    st = stations
    for x in st.keys():
        b.append(x)
    if K > len(b):
        K = len(b)
    mix_all_max = []
    y = []
    max_value = []

    for i in range(K):
        if  len(mix_all_max) < K:
            a = []
            p = 0
            value_temp = []
            for x in st.keys():
                a.append(x)
            for i in range(len(a)):
                value_temp.append(st[a[i]]['temp'])
            max_va = max(value_temp)
            for i in range(len(a)):
                if max_va == st[a[i]]['temp'] and len(max_value) < K:
                    x = a[i]
                    y.append(st[x])
                    mix_all_max.append(x)
                    max_value.append(max_va)
                    if st[a[i]]['temp'] == max_value[p]:
                        mix_all_max.sort()
                        p += 1
                    st.pop(x)
    for i in range(len(y)):
        st[mix_all_max[i]] = y[i]
    return mix_all_max
def peak_stations(stations):
    a = []
    value_lat = []
    value_long = []
    st = stations
    for x in st.keys():
        a.append(x)
    for i in range(len(a)):
        value_lat.append(st[a[i]]['lat'])
        value_long.append(st[a[i]]['long'])
    min_of_lat = min(value_lat)
    max_of_lat = max(value_lat)
    min_of_long = min(value_long)
    max_of_long = max(value_long)
    for i in range(len(a)):
        if min_of_lat == st[a[i]]['lat']:
            min_lat = a[i]
        if min_of_long == st[a[i]]['long']:
            min_long = a[i]
        if max_of_lat == st[a[i]]['lat']:
            max_lat = a[i]
        if max_of_long == st[a[i]]['long']:
            max_long = a[i]
    return min_lat, min_long, max_lat, max_long
def k_nearby_stations(stations, main_station, K):
    st = stations
    b = []
    for x in st.keys():
        b.append(x)
    if K > len(b)-1:
        K = len(b)-1
    a = []
    all_min_dt = []
    alldistance = []
    near_station = []

    for x in st.keys():
        a.append(x)
    for i in range(len(a)):
        lat2 = st[a[i]]['lat']
        long2 = st[a[i]]['long']
        if a[i] != main_station:
            lat1 = st[main_station]['lat']
            long1 = st[main_station]['long']
            distance_from_main = distance(lat1, long1, lat2, long2)
            alldistance.append(distance_from_main)

    for i in range(K):
        min_distance = min(alldistance)
        all_min_dt.append(min_distance)
        alldistance.remove(min_distance)

    for i in range(len(a)):
        lat2 = st[a[i]]['lat']
        long2 = st[a[i]]['long']
        aa = a[i]
        if a[i] != main_station:
            lat1 = st[main_station]['lat']
            long1 = st[main_station]['long']
            for i in range(len(all_min_dt)):
                if all_min_dt[i] == distance(lat1, long1, lat2, long2):
                    near_station.append(aa)

    return near_station
def average_temp(stations, names):
    a = []
    t = 0
    st = stations
    value_temp = []
    for x in st.keys():
        a.append(x)
    for i in range(len( names)):
        value_temp.append(st[names[i]]['temp'])
    su = value_temp
    for i in range(len(su)):
        t += float(su[i])
    average = t/len( names)
    return average

# --------------------------------------------------
# 6330423221 (16.64) 252 (2021-03-29 17:42)

def approx_match(stations, name):
    xx=[]
    name=name.upper()
    block=""
    for e in name:
        if "A"<=e<="Z":
            block+=e
    for e in stations :
        if block in e.upper():
            xx.append(e)
    return xx
def top_k_min_temp_stations(stations, K):
    Temp_allsta={}
    for e in stations:
        Temp_allsta[stations[e]['temp']]=e
    q=[]
    for e in Temp_allsta:
        q.append(e)
    q.sort()

    aaa=[]
    for i in range(K):
        aaa.append( Temp_allsta[q[i]])
    return aaa
def top_k_max_temp_stations(stations, K):
    Temp_allsta={}
    for e in stations:
        Temp_allsta[stations[e]['temp']]=e
    q=[]
    for e in Temp_allsta:
        q.append(-e)
    q.sort()

    aaa=[]
    for i in range(K):
        aaa.append(Temp_allsta[-q[i]])
    return aaa
def peak_stations(stations):
    long={}
    for e in stations:
        long[stations[e]['long']]=e
    long1=[]
    for e in long:
        long1.append(e)
    LOWlong=min(long1)
    HIGHTlong=max(long1)

    lat={}
    for e in stations:
        lat[stations[e]['lat']]=e
    lat1=[]
    for e in lat:
        lat1.append(e)
    LOWlat=min(lat1)
    HIGHTlat=max(lat1)



    return long[LOWlong],long[HIGHTlong],lat[LOWlat],lat[HIGHTlat]
##################################################################
##################################################################
def k_nearby_stations(stations, main_station, K):
    DDD=[]
    DDDDD=[]
    D={}
    date_time, names_in_region, stations = read_weather_data()
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for e in stations:
        lat2=stations[e]['lat']
        long2=stations[e]['long']
        dista=distance(lat1, long1, lat2, long2)
        D[dista]=e
        DDD.append(dista)
    DDD.sort()
    for i in range(K+1):
        DDDDD.append(D[DDD[i]])
    return DDDDD[1:]
def average_temp(stations, names):
    avg = 0
    n = 0
    for e in names:
        avg += stations[e]['temp']
        n += 1
    avg = avg/n
    return avg









# --------------------------------------------------
# 6330424921 (21.66) 253 (2021-03-26 15:12)

def approx_match(stations, name):
    name = name.lower().split()
    station_lower= []
    show = []
    stations_key =[]
    for e in stations:
        stations_key.append(e)
    for i in stations:
        station_lower.append(i.lower())
    for i in name:
        for e in range(len(station_lower)) :
            if i in station_lower[e] and i not in show :
                show.append(stations_key[e])
    return show
def top_k_min_temp_stations(stations, K):
    t = []
    show =[]
    for i in stations:
        t.append([float(stations[i]['temp']),i])
    t.sort()
    for i in range(K):
        if i == len(t):
            break
        else:
            show.append(t[i][1])

    return show
def top_k_max_temp_stations(stations, K):
    t = []
    show =[]
    for i in stations:
        t.append([float(-stations[i]['temp']),i])
    t.sort()
    for i in range(K):
        if i == len(t):
            break
        else:
            show.append(t[i][1])

    return show
def peak_stations(stations):
    lat = []
    long = []
    for i in stations:
        lat.append([float(stations[i]['lat']),i])
    lat.sort()
    for i in stations:
        long.append([float(stations[i]['long']),i])
    long.sort()
    show = [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return show
def k_nearby_stations(stations, main_station, K):
    distances = []
    show =[]
    for i in stations:
        distances.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i])
    distances.sort()
    for i in range(K):
        if i == len(distances):
            break
        else:
            show.append(distances[i][1])
    return show
def average_temp(stations, names):
    temperature = []
    for i in names:
        temperature.append(stations[i]['temp'])
    return sum(temperature)/len(temperature)


# --------------------------------------------------
# 6330425521 (30) 254 (2021-03-29 01:17)

def approx_match(stations, name):
    list_key = []
    a = []
    n = ''
    for i in range(len(name)):
        if name[i] == ' ':
            n += ''
        else:
            n += name[i].upper()
    for s in stations:
        list_key.append(s)
    for s in list_key:
        if n.upper() in s.upper().replace(' ',''):
            a.append(s)
    return a
def top_k_min_temp_stations(stations, K):
    list_temp = []
    list_key = []
    list_of_list = []
    for s in stations.values():
        list_temp.append(s['temp'])
    for s in stations:
        list_key.append(s)
    for i in range(len(list_key)):
        list_of_list.append([list_temp[i], list_key[i]])
    list_of_list.sort()
    s = list_of_list[:K]
    return [e[1] for e in s]
def top_k_max_temp_stations(stations, K):
    list_temp = []
    list_key = []
    list_of_list = []
    for s in stations.values():
        list_temp.append(s['temp'])
    for s in stations:
        list_key.append(s)
    for i in range(len(list_key)):
        list_of_list.append([-list_temp[i], list_key[i]])
    list_of_list.sort()
    s = list_of_list[:K]
    return [e[1] for e in s]
def peak_stations(stations):
    list_lat = []
    list_long = []
    k = []
    list_of_lat = []
    list_of_long = []
    for s in stations.values():
        list_lat.append(s['lat'])
        list_long.append(s['long'])
    for s in stations:
        k.append(s)
    for i in range(len(list_lat)):
        list_of_lat.append([list_lat[i], k[i]])
        list_of_long.append([list_long[i], k[i]])
    list_of_lat.sort()
    list_of_long.sort()
    return [list_of_lat[0][1], list_of_lat[-1][1], list_of_long[0][1], list_of_long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat_main, long_main = stations[main_station]['lat'], stations[main_station]['long']
    distance_list = []
    key = []
    a = []
    for s in stations.values():
        distance_list.append(distance(s['lat'], s['long'], lat_main, long_main))
    for s in stations:
        key.append(s)
    for s in range(len(stations)):
        a.append([distance_list[s], key[s]])
    a.sort()
    return [e[1] for e in a[1:K+1]]
def average_temp(stations, names):
    temp_in_name = []
    avg = 0
    for s in names:
        temp_in_name.append(stations[s]['temp'])
    for s in temp_in_name:
        avg += s
    avg = avg/len(temp_in_name)
    return avg


# # --------------------------------------------------
# 6330426121 (30) 255 (2021-03-29 18:41)

def approx_match(stations, name):
    match = []
    x = ''
    for c in name:
        if c.lower() in 'abcdefghijklmnopqrstuvwxyz':
            x += c.upper()
    for key in stations:
        if x in key:
            match.append(key)
    return match
def top_k_min_temp_stations(stations, K):
    t_e_s = []
    top_k_min_t = []
    for key in stations:
        t_e_s.append([stations[key]['temp'],key])
    t_e_s.sort()
    for e in t_e_s:
        top_k_min_t.append(e[1])
    return top_k_min_t[:K]
def top_k_max_temp_stations(stations, K):
    t_e_s = []
    top_k_max_t = []
    for key in stations:
        t_e_s.append([stations[key]['temp'],key])
    t_e_s = sorted(t_e_s, reverse = True)
    check_eq = 0
    s = []
    for i in range(len(t_e_s)):
        if i > 0:
            if t_e_s[i][0] != check_eq:
                top_k_max_t += sorted(s)
                s = []
                check_eq = t_e_s[i][0]
                s.append(t_e_s[i][1])
            else:
                s.append(t_e_s[i][1])
        else:
            check_eq = t_e_s[i][0]
            s.append(t_e_s[i][1])
    top_k_max_t += sorted(s)
    return top_k_max_t[:K]
def peak_stations(stations):
    max_lat = 0
    max_lat_s = ''
    min_lat = 360
    min_lat_s = ''
    max_long = 0
    max_long_s = ''
    min_long = 360
    min_long_s = ''
    for key in stations:
        if stations[key]['lat'] > max_lat:
            max_lat = stations[key]['lat']
            max_lat_s = key
        if stations[key]['lat'] < min_lat:
            min_lat = stations[key]['lat']
            min_lat_s = key
        if stations[key]['long'] > max_long:
            max_long = stations[key]['long']
            max_long_s = key
        if stations[key]['long'] < min_long:
            min_long = stations[key]['long']
            min_long_s = key
    return [min_lat_s,max_lat_s,min_long_s,max_long_s]
def k_nearby_stations(stations, main_station, K):
    near_s = []
    top_k_near_s = []
    for key in stations:
        if key != main_station:
            near_s.append([distance(stations[main_station]['lat'], stations[main_station]['long'], \
                                    stations[key]['lat'], stations[key]['long']),key])
    near_s.sort()
    for e in near_s:
        top_k_near_s.append(e[1])
    return top_k_near_s[:K]
def average_temp(stations, names):
    sum_t = 0
    c = 0
    for name in names:
        if name in stations:
            sum_t += stations[name]['temp']
            c += 1
    return round(sum_t/c,1)


# --------------------------------------------------
# 6330427821 (28.74) 256 (2021-03-28 04:43)

def approx_match(stations, name):
    a = name.split()
    b = "".join(a)
    c = b.upper()
    s = []
    r = []
    for k in stations.items():
        s.append(k[0].upper())
    for i in range(len(s)):
        if c in s[i]:
            r.append(s[i])
    return r
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort()
    for i in range(K):
        b.append(a[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for i in stations:
        a.append([stations[i]['temp'],i])
    a.sort(reverse = True)
    for i in range(K):
        b.append(a[i][1])
    return b
def peak_stations(stations):
    a1 = []
    a2 = []
    a3 = []
    a4 = []
    b = []
    for i in stations:
        a1.append([stations[i]['lat'],i])
    a1.sort()
    b.append(a1[0][1])
    for i in stations:
        a2.append([stations[i]['lat'],i])
    a2.sort(reverse = True)
    b.append(a2[0][1])
    for i in stations:
        a3.append([stations[i]['long'],i])
    a3.sort()
    b.append(a3[0][1])
    for i in stations:
        a4.append([stations[i]['long'],i])
    a4.sort(reverse = True)
    b.append(a4[0][1])
    return b
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    a = []
    b = []
    c = []
    for i in stations:
        a.append([stations[i]['lat'],stations[i]['long'],i])
    for i in range(len(a)):
        lat2 = a[i][0]
        long2 = a[i][1]
        b.append([distance(lat1, long1, lat2, long2),a[i][2]])
    b.sort()
    b = b[1:]
    for i in range(K):
        c.append(b[i][1])
    return c
def average_temp(stations, names):
    a = 0
    b = []
    for i in range(len(names)):
        a += 1
        b.append(stations[names[i]]['temp'])
    c = sum(b)/a
    return c





# --------------------------------------------------
# 6330428421 (30) 257 (2021-03-29 20:57)

def approx_match(stations, name):
    result=[]
    for e in stations:
        if ''.join(name.upper().split()) in e:
            result.append(e)
    return result
def top_k_min_temp_stations(stations, K):
    temp=[]
    result=[]
    for e in stations:
        temp.append([stations[e]['temp'],e])
    temp.sort()
    if K > len(temp):
        K=len(temp)
    for i in range(K):
        result.append(temp[i][1])
    return result
def top_k_max_temp_stations(stations, K):
    temp=[]
    result=[]
    for e in stations:
        temp.append([(-1)*stations[e]['temp'],e])
    temp.sort()
    if K > len(temp):
        K=len(temp)
    for i in range(K):
        result.append(temp[i][1])
    return result
def peak_stations(stations):
    lati=[]
    longi=[]
    for e in stations:
        lati.append([stations[e]['lat'],e])
        longi.append([stations[e]['long'],e])
    result=[]
    result.append(min(lati)[1])
    result.append(max(lati)[1])
    result.append(min(longi)[1])
    result.append(max(longi)[1])
    return result
def k_nearby_stations(stations, main_station, K):
    if main_station in stations:
        lat=stations[main_station]['lat']
        long=stations[main_station]['long']
        dis=[]
        result=[]
        for e in stations:
            dis.append([distance(lat,long,\
                                 stations[e]['lat'],\
                                 stations[e]['long']),e])
        dis.sort()
        #print(dis)
        if K >= len(dis):
            K=len(dis)-1
        for i in range (1,K+1):
            result.append(dis[i][1])
        return result
def average_temp(stations, names):
    total=0
    count=0
    for e in names:
        if e in stations:
            count+=1
            total+=stations[e]['temp']
    return total/count


# --------------------------------------------------
# 6330429021 (30) 258 (2021-03-28 23:05)

def approx_match(stations, name):
    n = ''
    for i in range(len(name)):
        if name[i] == ' ':
            n += ''
        else:
            n += name[i]
    n = n.upper()
    s = []
    for e in stations:
        s.append(e)
    r = []
    for e in s:
        if n in e.upper().replace(' ',''):
            r.append(e)
    return r
def top_k_min_temp_stations(stations, K):
    temp = []
    names = []
    for e in stations:
        names.append(e)
    for e in stations:
        temp.append(stations[e]['temp'])
    s = []
    for i in range(len(temp)):
        s.append([temp[i],names[i]])
    s.sort()
    r = []
    for e in s:
        r.append(e[1])
    r = r[:K]
    return r
def top_k_max_temp_stations(stations, K):
    temp = []
    names = []
    for e in stations:
        names.append(e)
    for e in stations:
        temp.append(stations[e]['temp'])
    s = []
    for i in range(len(temp)):
        s.append([-temp[i],names[i]])
    s.sort()
    r = []
    for e in s:
        r.append(e[1])
    r = r[:K]
    return r
def peak_stations(stations):
    lati = []
    long = []
    s = []
    for e in stations.values():
        lati.append(e['lat'])
        long.append(e['long'])
    for e in stations:
        s.append(e)
    s_lati = []
    s_long = []
    for i in range(len(lati)):
        s_lati.append([lati[i],s[i]])
        s_long.append([long[i],s[i]])
    s_lati.sort()
    s_long.sort()
    r = []
    r.append(s_lati[0][1])
    r.append(s_lati[-1][1])
    r.append(s_long[0][1])
    r.append(s_long[-1][1])
    return r
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    s = []
    dis = []
    for e in stations:
        s.append(e)
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        dis.append(distance(lat1,long1,lat2,long2))
    dis_s = []
    for i in range(len(s)):
        dis_s.append([dis[i],s[i]])
    dis_s.sort()
    r = []
    for e in dis_s:
        r.append(e[1])
    r = r[1:K+1]
    return r
def average_temp(stations, names):
    temp = []
    n = 0
    for e in names:
        if e in stations:
            temp.append(stations[e]['temp'])
            n += 1
    avg = sum(temp)/n
    return avg

# --------------------------------------------------
# 6330430621 (30) 259 (2021-03-28 23:48)

def approx_match(stations, name):
    l = ''
    for e in name :
        if not e == ' ':
            l += e
    b = l.upper()
    a = []
    for key in stations:
        k = ''
        for e in key :
            if not e == '':
                k += e
        if b in k:
            a.append(key)
    return a
def top_k_min_temp_stations(stations, K):
    k = []
    for e in stations:
        t = stations[e]['temp']
        k.append([t,e])
    k.sort()
    m = k[:K]
    v = []
    for e in m:
        v.append(e[1])
    return v
def top_k_max_temp_stations(stations, K):
    k = []
    for e in stations:
        t = stations[e]['temp']
        k.append([-t,e])
    k.sort()
    m = k[:K]
    v = []
    for e in m:
        v.append(e[1])
    return v
def peak_stations(stations):
    k = []
    j = []
    for e in stations:
        t = stations[e]['lat']
        k.append([t,e])
        j.append([-t,e])
    j.sort()
    k.sort()
    v = []
    v.append(k[0][1])
    v.append(j[0][1])
    n = []
    m = []
    for e in stations:
        t = stations[e]['long']
        n.append([t,e])
        m.append([-t,e])
    n.sort()
    m.sort()
    v.append(n[0][1])
    v.append(m[0][1])
    return v
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    c = []
    for e in stations:
        lat2 = stations[e]['lat']
        long2 = stations[e]['long']
        d = distance(lat1, long1, lat2, long2)
        c.append([d,e])
    c.sort()
    m = c[:K+1]
    m.remove(m[0])
    v = []
    for e in m:
        v.append(e[1])
    return v
def average_temp(stations, names):
    i = 0
    for e in names:
        t = stations[e]['temp']
        i += t
    o = i/len(names)
    return o



# --------------------------------------------------
# 6330431221 (30) 260 (2021-03-29 15:02)

def approx_match(stations, name):
    name = name.strip().upper()
    x=[]
    check = ''
    for i in name:
        if 'A' <= i <= 'Z':
            check += i
    for e in stations:
        if check in e:
            x.append(e)
    return x
def top_k_min_temp_stations(stations, K):
    A=[]
    for i in stations:
        b = stations[i]['temp']
        A.append([b,i])
    A.sort()
    result=[]
    for e in A:
        result.append(e[1])
    results =result[:K]

    return results
def top_k_max_temp_stations(stations, K):
    a=[]
    for i in stations:
        b = stations[i]['temp']
        a.append([-b,i])
    a.sort()
    result=[]
    for e in a:
        result.append(e[1])
    results =result[:K]

    return results
def peak_stations(stations):
    lattitude=[]
    longtitude=[]
    for i in stations:
        a = stations[i]['lat']
        lattitude.append([a,i])
    for e in stations:
        b = stations[e]['long']
        longtitude.append([b,e])
    lattitude.sort()
    longtitude.sort()
    max_lat=lattitude[0][1]
    min_lat=lattitude[-1][1]
    max_long=longtitude[0][1]
    min_long=longtitude[-1][1]
    result = [max_lat,min_lat, max_long,min_long]

    return result
def k_nearby_stations(stations, main_station, K):
    lattitude_interested = stations[main_station]['lat']
    lattitude_list=[]
    for name in stations:
        latt = stations[name]['lat']
        lattitude_list.append([name,latt])
    lattitude_list.sort()
    longitude_interested = stations[main_station]['long']
    longitude_list=[]
    for name in stations:
        longg =stations[name]['long']
        longitude_list.append([name,longg])
    longitude_list.sort()
    DISTANCE=[]
    for i in range(len(longitude_list)):
        lat1=lattitude_list[i][1]
        long1=longitude_list[i][1]
        d=distance(lat1,long1,lattitude_interested,longitude_interested)
        DISTANCE.append([d,lattitude_list[i][0]])
    DISTANCE.sort()
    result=[]
    for e in DISTANCE:
        if e[1] != main_station:
           result.append(e[1])
    results =result[:K]

    return results
def average_temp(stations, names):
    up = 0
    down = 0
    for i in names:
        up += stations[i]['temp']
        down += 1
        result = up/down

    return result


# --------------------------------------------------
# 6330432921 (18) 261 (2021-03-28 09:16)

def approx_match(stations, name):
    allstation = []
    name = ("".join(name.split())).upper()

    for i in stations:
        stationsfix = "".join(i.split())
        if name in  stationsfix :
            allstation.append(i)

    return allstation
def top_k_min_temp_stations(stations, K):
    lstmin = []
    i = 0
    while i != K:
        if i != 0:
            if (alltemp[i][0] == alltemp[i-1][0]) :
                K += 1

            else:
                lstmin.append(alltemp[i][1])

        else:
            lstmin.append(alltemp[i][1])
        i += 1
        if(i == len(alltemp)-1):
            lstmin.append(alltemp[i][1])
            break
    return lstmin
def top_k_max_temp_stations(stations, K):
    lstmax = []
    i = 0
    while i != K:
        if i != 0:
            if (alltemp[len(alltemp)-1-i][0] == alltemp[len(alltemp)-i][0]) :
                K += 1
                lstmax.remove(alltemp[len(alltemp)-i][1])
                lstmax.append(alltemp[len(alltemp)-1-i][1])

            else:
                lstmax.append(alltemp[len(alltemp)-1-i][1])
        else:
            lstmax.append(alltemp[len(alltemp)-1-i][1])
        i += 1
        if(i == len(alltemp)-1):
            lstmax.append(alltemp[len(alltemp)-1-i][1])
            break
    return lstmax
def peak_stations(stations):
    peak = []
    peak.append(alllat[0][1])
    peak.append(alllat[len(alllat)-1][1])
    peak.append(alllong[0][1])
    peak.append(alllong[len(alllong)-1][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    nearest=[]
    alldis = []
    for i in stations:
        if(i != main_station.upper()):
            alldis.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[(i)]['lat'],stations[(i)]['long']),i])
    alldis.sort()
    i = 0
    while i != K :
        if i != 0:
            if (alldis[i][0] == alldis[i-1][0]) :
                K += 1

            else:
                nearest.append(alldis[i][1])

        else:
            nearest.append(alldis[i][1])
        i += 1

        if(i == len(alldis)-1):
            nearest.append(alldis[i][1])
            break
    return nearest
def average_temp(stations, names):
    total = 0
    for i in names:
        total+=stations[i]['temp']
    return total/len(names)

# --------------------------------------------------
# 6330433521 (30) 262 (2021-03-28 19:25)

def approx_match(stations, name):
    n = ''
    for e in name:
        if e == ' ':
            n += ''
        else: n += e
    n = n.upper()
    w = []
    for key in stations:
        keys = key.replace(' ','')
        if n in keys.upper():
            w.append(key)
    return w
def top_k_min_temp_stations(stations, K):
    w = [[stations[i]['temp'],i] for i in stations]
    w.sort()
    s = w[:K]
    x = []
    for i in range(len(s)):
        x.append(s[i][1])
    return x
def top_k_max_temp_stations(stations, K):
    w = [[(-1)*float(stations[i]['temp']),i] for i in stations]
    w.sort()
    s = w[:K]
    x = []
    for i in range(len(s)):
        x.append(s[i][1])
    return x
def peak_stations(stations):
    st = []
    w = [[float(stations[i]['lat']),i] for i in stations]
    w.sort()
    s1 = w[0][1]
    s2 = w[-1][1]
    x = [[float(stations[i]['long']),i] for i in stations]
    x.sort()
    t1 = x[0][1]
    t2 = x[-1][1]
    st = [s1,s2,t1,t2]
    return st
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    d = [[distance(lat1,long1,float(stations[i]['lat']),float(stations[i]['long'])),i] for i in stations]
    d.sort()
    d = d[1:]
    w = d[:K]
    x = []
    for e in w:
        x.append(e[1])
    return x
def average_temp(stations, names):
    x = 0
    n = len(names)
    for e in names:
        x += float(stations[e]['temp'])
    w = x/n
    return w



# --------------------------------------------------
# 6330434121 (30) 263 (2021-03-28 23:16)

def approx_match(stations, name):
    a = []
    realname = name.upper()
    c = ""
    for i in range(len(realname)):
        if realname[i] in "ABCDEFGHIJKLMNOPQRSTUVXYZ":
            c += realname[i]
    for k in stations:
        if c in k.upper().replace(" ",""):
            a.append(k)
    return a
def top_k_min_temp_stations(stations, K):

    a = []
    c = []
    for k in stations:
        a.append([stations[k]['temp'],k])
    a.sort()
    for i in range(K):
        if i < len(stations):
            c.append(a[i][1])


    return c
def top_k_max_temp_stations(stations, K):
    a = []
    c = []
    for k in stations:
        a.append([-stations[k]['temp'],k])
    a.sort()
    for i in range(K):
        if i < len(stations):
            c.append(a[i][1])



    return c
def peak_stations(stations):
    a = []
    b = []
    c = []
    d = []
    for k in stations:
        b.append(k)
        c.append(stations[k]['lat'])
        d.append(stations[k]['long'])
    for i in range(len(c)):
        if c[i] == min(c):
            a.append(b[i])
    for i in range(len(c)):
        if c[i] == max(c):
            a.append(b[i])
    for i in range(len(d)):
        if d[i] == min(d):
            a.append(b[i])
    for i in range(len(d)):
        if d[i] == max(d):
            a.append(b[i])






    return a
def k_nearby_stations(stations, main_station, K):
    a = []
    b = []
    c = []
    lat = stations[main_station]['lat']
    long = stations[main_station]['long']
    for k in stations:
        dt =  distance(stations[k]['lat'], stations[k]['long'], lat, long)
        a.append([dt,k])
        dt = 0
    a.sort()
    for i in range(1,K+1,1):
        if i < len(stations):
            c.append(a[i][1])


    return c
def average_temp(stations, names):
    a = 0
    b = 0
    for k in stations:
        if k in names:
            a += stations[k]['temp']
            b += 1
    a = a/b


    return a



# --------------------------------------------------
# 6330435821 (30) 264 (2021-03-27 03:12)

def approx_match(stations, name):
    def remove_blank(x):
        new_x=''
        for letter in x.upper():
            if letter!=' ':
                new_x+=letter
        return new_x

    match_list = []
    if remove_blank(name)!='':
        for e in stations:
            if remove_blank(name) in remove_blank(e):
                match_list.append(e)
    return match_list
def top_k_min_temp_stations(stations, K):
    stations_Tmin_Tmax=[]
    for e in stations:
        stations_Tmin_Tmax.append([stations[e]['temp'],e])
    stations_Tmin_Tmax.sort()
    top_min=[]
    for i in range(min(K,len(stations_Tmin_Tmax))):
        top_min.append(stations_Tmin_Tmax[i][1])
    return top_min
def top_k_max_temp_stations(stations, K):
    stations_nTmax_nTmin = []
    for e in stations:
        stations_nTmax_nTmin.append([-stations[e]['temp'], e])
    stations_nTmax_nTmin.sort()
    top_max = []
    for i in range(min(K,len(stations_nTmax_nTmin))):
        top_max.append(stations_nTmax_nTmin[i][1])
    return top_max
def peak_stations(stations):
    peak_lat=[]
    peak_long = []
    for e in stations:
        peak_lat.append([stations[e]['lat'],e])
        peak_long.append([stations[e]['long'],e])
    peak_lat.sort()
    peak_long.sort()
    return [peak_lat[0][1],peak_lat[-1][1],peak_long[0][1],peak_long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    main_lat = stations[main_station]['lat']
    main_long = stations[main_station]['long']
    d_list = []
    for e in stations:
        if e!=main_station:
            e_lat = stations[e]['lat']
            e_long = stations[e]['long']
            d_list.append([distance(main_lat, main_long, e_lat, e_long), e])
    d_list.sort()
    province_list=[]
    for province in d_list:
        province_list.append(province[1])
    return province_list[:K]
def average_temp(stations, names):
    sum_temp=0.0
    num_temp=0
    for e in names:
        if e in stations:
            sum_temp+=stations[e]['temp']
            num_temp+=1
    return sum_temp/num_temp


# --------------------------------------------------
# 6330436421 (28.4) 265 (2021-03-29 17:13)

def approx_match(stations, name):
    """
    :param stations: dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
    :param name: เป็นสตริง
    :return: คืนลิสต์ที่เก็บชื่อสถานีที่มีตัวอักษรใน name เป็นส่วนหนึ่งของชื่อสถานี โดยไม่สนใจว่าเป็นตัวพิมพ์เล็กหรือใหญ่
    และไม่สนใจเว้นวรรคภายในด้วย (ชื่อในลิสต์ที่คืนเป็นผลลัพธ์เรียงอย่างไรก็ได้)
    หมายเหตุ: ชื่อสถานีที่เป็นคีย์ใน stations นั้นเป็นตัวพิมพ์ใหญ่หมด ผลที่คืนจากฟังก์ชันนี้ก็จะเก็บตัวพิมพ์ใหญ่
    แต่ตอนค้น name ใน stations นั้น ต้องเป็นแบบไม่สนใจว่าเป็นตัวพิมพ์เล็กหรือใหญ่
    """
    # Declare a variable
    result = []
    # Normally, when we write this functon write search string we use 'Recursion' but I know that you are not study
    # recursion because it's a programming strategy that is hard. So we are use a way that is a little bit stupid
    # bur confirm that you are all know that what a program do.
    # Ps. First, I think I will use Recursion with Higher-Order function (To make a recursion in this function
    # and not make a code to ugly and CLEAN) but I think your teacher will say "WTF! How you know that? Holy shit"

    # Convert a string to a list
    # Search key
    # First, our dict is all capital letters so upper it
    name = name.upper()
    # Convert search keyword to list and remove space out
    name = name.replace(' ', '')
    # Convert it to list
    name_list = list(name)
    # Use Typecasting to get all dict key from variable 'stations'
    station_name_list = list(stations.keys())
    # For loop to search
    for station in station_name_list:
        station_list = station.upper()
        station_list = station_list.replace(' ', '')
        station_list = list(station_list)
        # Use all() function and for loop in one lineto check search keyword in station name
        if all(item in station_list for item in name_list):
            result.append(station)
    return result
def top_k_min_temp_stations(stations, K):
    """
        :param stations: dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
        :param K: จำนวนเต็มบวก
        :return ลิสต์ของชื่อสถานีที่มีอุณหภูมิต่ำสุด K สถานี ให้เรียงจากซ้ายไปขวาตามสถานีที่มีอุณหภูมิต่ำสุดไปสูงขึ้น
        ในกรณีที่มีอุณหภูมิเท่ากัน ให้เลือกสถานีที่มีชื่อมาก่อนตามลำดับในพจนานุกรม ในกรณีที่มีไม่ถึง K สถานี ก็คืนเท่าที่มี
        """
    station_name_list = list(stations.keys())
    temp_list = []
    for name in station_name_list:
        temp_list.append(stations[name]["temp"])
    # Make a dict with station and temp
    temp_dict = {}
    for i in range(len(station_name_list)):
        temp_dict[station_name_list[i]] = temp_list[i]
    sorted_keys = sorted(temp_dict, key=temp_dict.get)
    # To not make it error, if K more than len of dict, let K = len of dict
    if K > len(temp_dict):
        output_len = len(temp_dict)
    else:
        output_len = K
    return sorted_keys[0:output_len]
def top_k_max_temp_stations(stations, K):
    """
        :param stations: dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
        :param K: จำนวนเต็มบวก
        :return ลิสต์ของชื่อสถานีที่มีอุณหภูมิสูงสุด K สถานี ให้เรียงจากซ้ายไปขวาตามสถานีที่มีอุณหภูมิสูงสุดไปต่ำลง
        ในกรณีที่มีอุณหภูมิเท่ากัน ให้เลือกสถานีที่มีชื่อมาก่อนตามลำดับในพจนานุกรม ในกรณีที่มีไม่ถึง K สถานี ก็คืนเท่าที่
        มี
        """
    # Just copy top_k_min_temp_stations and change some code to get max
    station_name_list = list(stations.keys())
    temp_list = []
    for name in station_name_list:
        temp_list.append(stations[name]["temp"])
    # Make a dict with station and temp
    temp_dict = {}
    for i in range(len(station_name_list)):
        temp_dict[station_name_list[i]] = temp_list[i]
    sorted_keys = sorted(temp_dict, key=temp_dict.get, reverse=True)
    # To not make it error, if K more than len of dict, let K = len of dict
    if K > len(temp_dict):
        output_len = len(temp_dict)
    else:
        output_len = K
    return sorted_keys[0:output_len]
def peak_stations(stations):
    # Make a station name list
    station_name_list = list(stations.keys())
    lat_list = []
    for name in station_name_list:
        lat_list.append(stations[name]["lat"])
    long_list = []
    for name in station_name_list:
        long_list.append(stations[name]["long"])
    # We get a list of lat and long then find a max and min of lat and long and put it in a new variable as a float.
    lat_max = max(lat_list)
    lat_min = min(lat_list)
    long_max = max(long_list)
    long_min = min(long_list)
    # For loop to get a station name
    for i in range(len(station_name_list)):
        if lat_list[i] == lat_max:
            lat_max_station = station_name_list[i]
    for i in range(len(station_name_list)):
        if lat_list[i] == lat_min:
            lat_min_station = station_name_list[i]
    for i in range(len(station_name_list)):
        if long_list[i] == long_max:
            long_max_station = station_name_list[i]
    for i in range(len(station_name_list)):
        if long_list[i] == long_min:
            long_min_station = station_name_list[i]
    return lat_min_station,lat_max_station,long_min_station,long_max_station
def k_nearby_stations(stations, main_station, K):
    station_name_list = list(stations.keys())
    lat_list = []
    for name in station_name_list:
        lat_list.append(stations[name]["lat"])
    long_list = []
    for name in station_name_list:
        long_list.append(stations[name]["long"])
    # Get main_station lat and long
    main_station_index = station_name_list.index(main_station)
    main_station_lat = lat_list[main_station_index]
    main_station_long = long_list[main_station_index]
    cal_list = []
    for i in range(len(station_name_list)):
        cal_list.append(distance(lat_list[i], long_list[i], main_station_lat, main_station_long))
    # Make a dict of name and distance
    name_distance_dict = {}
    for i in range(len(station_name_list)):
        name_distance_dict[station_name_list[i]] = cal_list[i]
    # Delete main_station itself out from a dict
    del name_distance_dict[main_station]
    # Sort a dict
    sorted_keys = sorted(name_distance_dict, key=name_distance_dict.get)
    # To not make it error, if K more than len of dict, let K = len of dict
    if K > len(sorted_keys):
        output_len = len(sorted_keys)
    else:
        output_len = K
    return sorted_keys[0:output_len]
def average_temp(stations, names):
    station_name_list = list(stations.keys())
    temp_list = []
    calculation_list = []
    for name in station_name_list:
        temp_list.append(stations[name]["temp"])
    for station in names:
        station_index = station_name_list.index(station)
        calculation_list.append(temp_list[station_index])
    return sum(calculation_list)/len(calculation_list)

# If you put another line note again I will get Kasumi to 'BanG Dream!' you. (The 3 line is not the same too. WUT)
# 6330437021 (30) 266 (2021-03-29 17:49)

def approx_match(stations, name):
    A=[]
    B=""
    C=""
    a=""
    for i in name:
        if i!=" ":
            B+=i.upper()
    if B=="":
        return[]
    for e in stations:
        C=""
        a=e
        for i in a:
            if i!=" ":
                C+=i.upper()
        if B in C:
            A.append(e)
    return A
def top_k_min_temp_stations(stations, K):
    D=[]
    F=[]
    for i in stations:
            D.append([stations[i]["temp"],i])
            D.sort()
            E=D[0:K]
    for i in E:
        F.append(i[1])
    return F
def top_k_max_temp_stations(stations, K):
    D=[]
    F=[]
    for i in stations:
            D.append([-stations[i]["temp"],i])
            D.sort()
            E=D[0:K]
    for i in E:
        F.append(i[1])
    return F
def peak_stations(stations):
    G=[]
    K=[]
    for i in stations:
        G.append([stations[i]["lat"],i])
        G.sort()
        H=G[0][1]
        J=G[-1][1]
    for i in stations:
        K.append([stations[i]["long"],i])
        K.sort()
        L=K[0][1]
        N=K[-1][1]
    O=[H,J,L,N]
    return O
def k_nearby_stations(stations, main_station, K):
    P=[]
    Q=[]
    for i in stations:
        if i != main_station:
            R=distance(stations[i]["lat"],stations[i]["long"],stations[main_station]["lat"],stations[main_station]["long"])
            P.append([R,i])
            P.sort()
            S=P[0:K]
    for i in S:
        Q.append(i[1])
    return Q
def average_temp(stations, names):
    T=0
    for i in names:
        T+=stations[i]["temp"]
        U=T/len(names)
    return U




# --------------------------------------------------
# 6330438721 (28.74) 267 (2021-03-29 18:08)

def approx_match(stations, name):
    name = "".join(name.upper().split())
    s = []
    for e in stations:
        if name in e:
            s.append(e)
    return s
def top_k_min_temp_stations(stations, K):
    s = []
    for e in stations:
        s.append([stations[e]["temp"], e])
    s.sort()
    x = s[:K]
    Min = []
    for e in x:
        Min.append(e[1])
    return Min
def top_k_max_temp_stations(stations, K):
    s = []
    for e in stations:
        s.append([stations[e]["temp"], e])
    s.sort()
    x = s[::-1][:K]
    Max = []
    for e in x:
        Max.append(e[1])
    return Max
def peak_stations(stations):
    lat = []
    long = []
    for e in stations:
        lat.append([stations[e]["lat"], e])
        long.append([stations[e]["long"], e])
    lat.sort()
    long.sort()
    min_lat = lat[0][1]
    max_lat = lat[-1][1]
    min_long = long[0][1]
    max_long = long[-1][1]
    r = [min_lat, max_lat, min_long, max_long]
    return r
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    s = []
    for e in stations:
        s.append([distance(stations[main_station]["lat"], stations[main_station]["long"], stations[e]["lat"], stations[e]["long"]), e])
    s.sort()
    x = s[1:K+1]
    near = []
    for e in x:
        near.append(e[1])
    return near
def average_temp(stations, names):
    s = 0
    for e in names:
        s += stations[e]["temp"]
    avg = s/len(names)
    return avg

# --------------------------------------------------
# 6330439321 (28.74) 268 (2021-03-29 17:59)

def approx_match(stations, name):

    # clean name
    new_name = ''
    for c in name.upper():
        if c != ' ':
            new_name += c

    match_list = list()

    for uncleaned_station in stations.keys():

        # clean station
        station = ''
        for c in uncleaned_station.upper():
            if c != ' ':
                station += c

        if len(new_name) <= len(station):

            t = 0

            for i in range(len(station)):

                if t == len(new_name):
                    break
                if new_name[t] == station[i]:
                    t += 1
                else:
                    t = 0
                    if new_name[t] == station[i]:
                        t += 1

            if t == len(new_name):
                match_list.append(uncleaned_station)

    return match_list
def top_k_min_temp_stations(stations, K):

    unsorted = list()

    for k, v in stations.items():

        unsorted.append(Pointer(k, v['temp']))

    sorted_array = mergesort(unsorted)

    if len(unsorted) >= K:
        x = sorted_array[0:K]
    else:
        x = sorted_array

    return_list = list()
    for c in x:
        return_list.append(c.name)

    return return_list
def top_k_max_temp_stations(stations, K):
    unsorted = list()

    for k, v in stations.items():
        unsorted.append(Pointer(k, v['temp']))

    sorted_array = mergesort(unsorted)
    sorted_array = sorted_array[::-1]

    if len(unsorted) >= K:
        x = sorted_array[0:K]
    else:
        x = sorted_array

    return_list = list()
    for c in x:
        return_list.append(c.name)

    return return_list
def peak_stations(stations):

    if len(stations) == 0:
        return []

    x = stations.items()

    for k, v in x:

        f_name = k
        lat = v['lat']
        long = v['long']
        break

    min_lat, min_lat_name = lat, f_name
    max_lat, max_lat_name = lat, f_name
    min_long, min_long_name = long, f_name
    max_long, max_long_name = long, f_name

    # find max lat and long
    for k, v in x:

        lat = v['lat']
        long = v['long']

        if lat > max_lat:
            max_lat = lat
            max_lat_name = k

        elif lat < min_lat:
            min_lat = lat
            min_lat_name = k

        if long > max_long:
            max_long = long
            max_long_name = k

        elif long < min_long:
            min_long = long
            min_long_name = k

    return [min_lat_name, max_lat_name, min_long_name, max_long_name]
def k_nearby_stations(stations, main_station, K):

    K += 1   # add center station

    center = stations[main_station]
    lat_ct = center['lat']
    long_ct = center['long']
    unsorted_distance = list()

    for k, v in stations.items():
        unsorted_distance.append(Pointer(k, distance(lat_ct, long_ct, v['lat'], v['long'])))

    sorted_distance = mergesort(unsorted_distance)

    return_list = list()

    if len(sorted_distance) > K:
        top_K = sorted_distance[0:K]
    else:
        top_K = sorted_distance

    for p in top_K:
        return_list.append(p.name)

    return return_list[1::]
def average_temp(stations, names):

    s = 0

    for n in names:
        s += stations[n]['temp']

    # name definitely > 0
    return s / len(names)


# --------------------------------------------------
# var
def mergesort(array):

    if len(array) == 1:
        return array

    mid = len(array) // 2

    fore = mergesort(array[0: mid])
    back = mergesort(array[mid:])

    n_fore = len(fore)
    n_back = len(back)
    i, j = 0, 0

    sorted_array = list()

    while i < n_fore and j < n_back:

        if fore[i] < back[j]:
            sorted_array.append(fore[i])
            i += 1
        elif fore[i] > back[j]:
            sorted_array.append(back[j])
            j += 1
        else:
            sorted_array.append(fore[i])
            sorted_array.append(back[j])
            i += 1
            j += 1

    while i < n_fore:

        sorted_array.append(fore[i])
        i += 1

    while j < n_back:

        sorted_array.append(back[j])
        j += 1

    return sorted_array
# 6330440921 (30) 269 (2021-03-25 16:30)

def approx_match(stations, name):
    station_names = []
    for real_name in stations:
        if simply(name) in simply(real_name):
            station_names.append(real_name)
    return station_names
def top_k_min_temp_stations(stations, K):
    temp, min_temp = [], []
    for name in stations:
        temp.append([stations[name]['temp'], name])
    temp.sort()
    if len(temp) < K: N = len(temp)
    else: N = K
    for i in range(N):
        min_temp.append(temp[i][1])
    return min_temp
def top_k_max_temp_stations(stations, K):
    temp, max_temp = [], []
    for name in stations:
        temp.append([-stations[name]['temp'], name])
    temp.sort()
    if len(temp) < K: N = len(temp)
    else: N = K
    for i in range(N):
        max_temp.append(temp[i][1])
    return max_temp
def peak_stations(stations):
    lat, long = [], []
    for name in stations:
        lat.append([stations[name]['lat'], name])
        long.append([stations[name]['long'], name])
    lat.sort()
    long.sort()
    peak = [lat[0][1], lat[-1][1], long[0][1], long[-1][1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    near_by, dis = [], []
    main_lat = stations[main_station]['lat']
    main_long = stations[main_station]['long']
    for name in stations:
        if name != main_station:
            dis.append([distance(stations[name]['lat'], stations[name]['long'], main_lat, main_long), name])
    dis.sort()
    if len(dis) < K: N = len(dis)
    else: N = K
    for i in range(N):
        near_by.append(dis[i][1])
    return near_by
def average_temp(stations, names):
    temp = []
    for name in names:
        temp.append(stations[name]['temp'])
    return sum(temp)/len(temp)

# --------------------------------------------------
def simply(name):
    simp_name = ''
    name = name.upper().strip()
    for i in range(len(name)):
        if 'A' <= name[i] <= 'Z':
            simp_name += name[i]
    return simp_name
# 6330441521 (30) 270 (2021-03-29 19:34)

def approx_match(stations, name):
    name = name.replace(' ','').upper()
    out = []
    for i in stations.keys():
        if name in i.replace(' ','').upper():
            out.append(i)
    return out
def top_k_min_temp_stations(stations, K):
    statemp = []
    sta = []
    for i in stations.keys():
        statemp.append([stations[i]['temp'],i])
    statemp = sorted(statemp)
    for i in statemp[:K]:
        sta.append(i[1])
    return sta
def top_k_max_temp_stations(stations, K):
    statemp = []
    sta = []
    for i in stations.keys():
        statemp.append([stations[i]['temp']*(-1),i])

    statemp = sorted(statemp)
    for i in statemp[:K]:
        sta.append(i[1])
    return sta
def peak_stations(stations):
    mins = math.inf
    x = ''
    maxs = -math.inf
    stalist = []
    for i in stations.keys():
        if stations[i]['lat'] < mins:
            mins = stations[i]['lat']
            x = i
    stalist.append(x)
    mins = math.inf
    for i in stations.keys():
        if stations[i]['lat'] > maxs:
            maxs = stations[i]['lat']
            x = i
    stalist.append(x)
    maxs = -math.inf
    for i in stations.keys():
        if stations[i]['long'] < mins:
            mins = stations[i]['long']
            x = i
    stalist.append(x)
    mins = math.inf
    for i in stations.keys():
        if stations[i]['long'] > maxs:
            maxs = stations[i]['long']
            x = i
    stalist.append(x)
    maxs = -math.inf
    return stalist
def k_nearby_stations(stations, main_station, K):
    listd = []
    sta = []
    for i in stations.keys():
        x = distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long'])
        if x != 0:
            listd.append([x,i])
    listd = sorted(listd)
    for i in listd[:K]:
        sta.append(i[1])
    return sta
def average_temp(stations, names):
    t = 0
    for d in names:
        t += stations[d]['temp']
    avg = t/len(names)
    return avg


# --------------------------------------------------
# 6330443821 (26) 271 (2021-03-29 10:25)

def approx_match(stations, name):
    name2 = ''
    lst = []
    for e in name:
        if e == ' ':
            name2 += ''
        elif e.isalpha():
            name2 += e.upper()
    for e in stations:
        if name2 in e:
            lst.append(e)
    return lst
def top_k_min_temp_stations(stations, K):

    sta_name = []
    sta_name2 = []

    for i in stations:
        sta_name.append([stations[i]['temp'], i])

    sta_name.sort()
    sta_name = sta_name[:K]

    for i in range(K):
        try:
            sta_name2.append(sta_name[i][1])
        except:
            pass

    return sta_name2
def top_k_max_temp_stations(stations, K):

    sta_name = []
    sta_name2 = []

    for i in stations:
        sta_name.append([stations[i]['temp'], i])

    sta_name.sort(key=lambda x: x[0], reverse=True)
    sta_name = sta_name[:K]

    for i in range(K):
        try:
            sta_name2.append(sta_name[i][1])
        except:
            pass

    return sta_name2
def peak_stations(stations):
    lat_list = []
    long_list = []
    for i in stations:
        lat_list.append(stations[i]['lat'])
        long_list.append(stations[i]['long'])
    lat_list.sort()
    long_list.sort()
    return get_key_lat(lat_list[0]), get_key_lat(lat_list[-1]), get_key_long(long_list[0]), get_key_long(long_list[-1])
def k_nearby_stations(stations, main_station, K):
    dis_list = []
    dis_list2 = []
    for i in stations:
        dis_list.append([ distance(stations[i]['lat'], stations[i]['long'], stations[main_station]['lat'], stations[main_station]['long']),i])
    dis_list.sort()

    for i in range(K+1):
        try:
            dis_list2.append(dis_list[i][1])
        except:
            pass
    return dis_list2[1:]
def average_temp(stations, names):
    summ = 0
    for i in names:
        summ += stations[i]['temp']
        #print(stations[i]['temp'])
    return summ/len(names)




# --------------------------------------------------
def get_key_lat(val):
    for key in stations:
        if val == stations[key]['lat']:
            return key
def get_key_long(val):
    for key in stations:
        if val == stations[key]['long']:
            return key
# 6330444421 (30) 272 (2021-03-29 17:22)

def approx_match(stations, name):
  stationNames = stations.keys()
  name = name.replace(" ", "").upper()
  result = []
  for n in stationNames:
    stationUpper = n.upper()
    if name in stationUpper:
      result.append(stationUpper)
  return result
def top_k_min_temp_stations(stations, K):
  stationsTemps = []
  for s in stations.keys():
    stationsTemps.append((stations[s]['temp'],s))
  stationsTemps = sorted(stationsTemps)[:K]
  return list(map(lambda x: x[1],stationsTemps))
def top_k_max_temp_stations(stations, K):
  stationsTemps = []
  for s in stations.keys():
    stationsTemps.append((stations[s]['temp'],s))
  stationsTemps = sorted(stationsTemps, key= lambda t: (-t[0],t[1]))[:K]
  return list(map(lambda x: x[1],stationsTemps))
def peak_stations(stations):
  minLat = min(stations, key=lambda k: stations[k]['lat'])
  maxLat = max(stations, key=lambda k: stations[k]['lat'])
  minLong = min(stations, key=lambda k: stations[k]['long'])
  maxLong = max(stations, key=lambda k: stations[k]['long'])
  return [minLat, maxLat, minLong, maxLong]
def k_nearby_stations(stations, main_station, K):
  distanceMain = map(lambda x: (distance(stations[main_station]['lat'],stations[main_station]['long'], stations[x]['lat'], stations[x]['long']), x), stations)
  distanceMain = sorted(distanceMain)
  return list(map(lambda x: x[1],distanceMain[1:K+1]))
def average_temp(stations, names):
  temps = 0
  for n in names:
    temps += stations[n]['temp']
  return temps / len(names)


# --------------------------------------------------
# 6330445021 (30) 273 (2021-03-26 14:37)

def approx_match(stations, name):
    n = ''.join(name.split()).upper()
    l = []
    for s in stations:
        st = ''.join(s.split())
        if st.find(n) != -1:
            l.append(s)
    return l
def top_k_min_temp_stations(stations, K):
    l = []
    for st in stations:
        l.append([stations[st]['temp'],st])
    l.sort()
    x = []
    for data in l[:K]:
        x.append(data[1])
    return x
def top_k_max_temp_stations(stations, K):
    l = []
    for st in stations:
        l.append([-stations[st]['temp'],st])
    l.sort()
    x = []
    for data in l[:K]:
        x.append(data[1])
    return x
def peak_stations(stations):
    lats = []
    lons = []
    for st in stations:
        lats.append([stations[st]['lat'], st])
        lons.append([stations[st]['long'], st])
    lats.sort()
    lons.sort()
    return [lats[0][1],lats[-1][1],lons[0][1],lons[-1][1]]
def k_nearby_stations(stations, main_station, K):
    l = []
    m = coords_of(stations[main_station])
    for st in stations:
        c = coords_of(stations[st])
        l.append([distance(m[0],m[1],c[0],c[1]), st])
    l.sort()
    x = []
    for i in l[1:K+1]:
        x.append(i[1])
    return x
def average_temp(stations, names):
    s = 0
    for i in names:
        s += stations[i]['temp']
    a = s/len(names)
    return a

# --------------------------------------------------
def coords_of(data):
    lat = data['lat']
    long = data['long']
    return [lat,long]
# 6330446721 (30) 274 (2021-03-27 20:24)

def approx_match(stations, name):
    nameFormat = ""
    name = name.lower()
    for v in name :
        if "a" <= v <= "z" :
            nameFormat += v
    result = []
    for s_name in stations :
        Lowerf = s_name.lower()
        if nameFormat in Lowerf :
            result.append(s_name)
    return result
def top_k_min_temp_stations(stations, K):
    pairData = [[stations[x]["temp"],x] for x in stations]
    sortData = sorted(pairData)
    ans = []
    for i in range(len(sortData)) :
        if i == K :
            break
        ans.append(sortData[i][1])
    return ans
def top_k_max_temp_stations(stations, K):
    pairData = [[-stations[x]["temp"],x] for x in stations]
    sortData = sorted(pairData)
    ans = []
    for i in range(len(sortData)) :
        if i == K :
            break
        ans.append(sortData[i][1])
    return ans
def peak_stations(stations):
    maxLatitude = [-1e9,'']
    maxLongtitude = [-1e9,'']
    minLatitude = [1e9,'']
    minLongtitude = [1e9,'']
    for x in stations :
        if stations[x]['lat'] > maxLatitude[0] :
            maxLatitude[0] = stations[x]['lat']
            maxLatitude[1] = x
        if stations[x]['long'] > maxLongtitude[0] :
            maxLongtitude[0] = stations[x]['long']
            maxLongtitude[1] = x
        if stations[x]['lat'] < minLatitude[0] :
            minLatitude[0] = stations[x]['lat']
            minLatitude[1] = x
        if stations[x]['long'] < minLongtitude[0] :
            minLongtitude[0] = stations[x]['long']
            minLongtitude[1] = x
    return [minLatitude[1],maxLatitude[1],minLongtitude[1],maxLongtitude[1]]
def k_nearby_stations(stations, main_station, K):
    data = []
    for x in stations :
        po1 = stations[x]
        po2 = stations[main_station]
        dis = distance(po1["lat"],po1["long"],po2["lat"],po2["long"])
        if x != main_station :
            data.append([dis,x])
    sort_data = sorted(data)
    ans = []
    for i in range(len(sort_data)) :
        if i == K :
            break
        ans.append(sort_data[i][1])
    return ans
def average_temp(stations, names):
    total_temp = 0
    cnt = 0
    for station in stations :
        if station in names :
            total_temp += stations[station]['temp']
            cnt+=1
    avg = total_temp/cnt
    return avg

# --------------------------------------------------
# 6330447321 (30) 275 (2021-03-29 02:15)

def approx_match(stations, name):
    name = name.upper().split()
    name = ''.join(name)
    return [sta for sta in stations if name in ''.join(sta.split())]
def top_k_min_temp_stations(stations, K):
    k_min = [[stations[k]['temp'], k] for k in stations]
    k_min.sort()
    k_min = k_min[:K:]
    return [k for t, k in k_min]
def top_k_max_temp_stations(stations, K):
    k_max = [[-stations[k]['temp'], k] for k in stations]
    k_max.sort()
    k_max = k_max[:K:]
    return [k for t, k in k_max]
def peak_stations(stations):
    several_lat = [[stations[k]['lat'], k] for k in stations]
    several_long = [[stations[k]['long'], k] for k in stations]
    several_lat.sort()
    several_long.sort()
    return [several_lat[0][1], several_lat[-1][1], several_long[0][1], several_long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat_main, long_main = stations[main_station]['lat'], stations[main_station]['long']
    k_near = [[distance(lat_main, long_main, stations[k]['lat'], stations[k]['long']), k] for k in stations]
    k_near.sort()
    k_sta = [k for dis, k in k_near]
    return k_sta[1:K+1:]
def average_temp(stations, names):
    temp = 0
    for n in names:
        temp += stations[n]['temp']
    return temp/len(names)

# --------------------------------------------------
# 6330448021 (30) 276 (2021-03-29 23:26)

# 6330449621 (23.6) 277 (2021-03-29 21:31)

def approx_match(stations, name):
    name = name.upper().replace(" ","")
    n = []

    for i in stations:
        if name in i.upper().replace(" ","") and name != "" :
            n.append(i)
    return n
def top_k_min_temp_stations(stations, K):
    m = []
    for i in stations :
        m += [[stations[i]["temp"],i]]

    t = []
    for i in sorted(m)[0:K] :
        t += [i[1]]
    return t
def top_k_max_temp_stations(stations, K):
    M = []
    for i in stations :
        M += [[-stations[i]["temp"],i]]

    T = []
    for i in sorted(M)[0:K] :
        T += [i[1]]
    return T
def peak_stations(stations):
    latitude = []
    longitude = []

    for i in stations :
        latitude += [[stations[i]["lat"],i]]
        longitude += [[stations[i]["long"],i]]
        a = min(latitude)[1]
        b = max(latitude)[1]
        c = min(longitude)[1]
        d = max(longitude)[1]
    return (a,b,c,d)
def k_nearby_stations(stations, main_station, K):
    a = stations[main_station]["lat"]
    b = stations[main_station]["long"]
    s = []

    for e in stations:
        s += [[distance(a,b,stations[e]["lat"],stations[e]["long"]),e]]

    n = []
    for e in sorted(s) :
        n += [e[1]]
    return n[1:K+1]
def average_temp(stations, names):
    import statistics
    av = []
    for e in names :
        av += stations[e]["temp"]
    return statistics.mean(av)



# --------------------------------------------------
# 6330450121 (27) 278 (2021-03-29 21:46)

def approx_match(stations, name):
    ans=list()

    newname=str()
    adf=str()
    #adf
    #name.upper()
    for c in name:

        if c != ' ':
            newname += c.upper()


    for k in stations:

        new_k=str()

        for c in k:
            if c != ' ':

                new_k += c.upper()

        if newname in new_k:
            ans.append(k)
        else:
            pass

    return ans
def top_k_min_temp_stations(stations, K):
    r=list()

    for k in stations:

        l=len(r)

        if l < K:
            temp = stations[k]['temp']

            r.append([temp , k])

            r.sort()

        elif l == K:

            for i in range(len(r)):
                closetemp=stations[k]['temp']

                if [closetemp , k] < r[i]:
                    temp = stations[k]['temp']
                    r.insert(i, [temp, k])
                    r.sort()
                    #r.pop(-1)
                    break
        else:
            pass
    a=list()
    for i in range(K):
        a.append(r[i][1])



    return a
def top_k_max_temp_stations(stations, K):
    r=list()
    for k in stations:

        l=len(r)

        if l < K:

            minustemp=(-stations[k]['temp'])
            r.append([minustemp, k])
            r.sort()

        elif l == K:

            for i in range(len(r)):
                minustemp=(-stations[k]['temp'])
                if [minustemp, k] < r[i]:
                    r.insert(i, [minustemp, k])
                    r=r[:-1]

                    break
        else:
            pass

    for i in range(len(r)):
        r[i] = [r[i][0],r[i][1]]
    # is this even necesary? idk
    a=list()

    for i in range(len(r)):
        a.append(r[i][1])
    #for i in range(len(r)):
        #r[i] = r[i][1]

    return a
def peak_stations(stations):

    r=list()

    for k in stations:

        if len(r) == 0:


            x=stations[k]['lat']
            y=stations[k]['long']
            r = [[x, k], [x, k],\
                 [y, k], [y, k]]

        else:
            x=stations[k]['lat']
            y=stations[k]['long']


            if [x, k] > r[1]:
                r[1] = [x, k]

            if [x, k] < r[0]:
                r[0] = [x, k]


            if [y, k] > r[3]:
                r[3] = [y, k]

            if [y, k] < r[2]:
                r[2] = [y, k]


            else:
                pass
    a=list()

    for i in range(len(r)):
        a.append(r[i][1])

    return a
def k_nearby_stations(stations, main_station, K):
    r=list()
    b=list()
    for k in stations:
        if k  !=  main_station:

            if len(r) < K:
                x1=stations[k]['lat']
                y1=stations[k]['long']
                x2=stations[main_station]['lat']
                y2=stations[main_station]['long']
                d = distance(x1, y1, x2, y2)

                r.append([d, k])
                r.sort()

            else:
                x1=stations[k]['lat']
                y1=stations[k]['long']
                x2=stations[main_station]['lat']
                y2=stations[main_station]['long']
                d = distance(x1, y1, x2, y2)

                for i in range(len(r)):
                    listo=[d,k]
                    if listo < r[i]:
                        r.insert(i, listo)
                        r.sort()

                        break
        else:
            pass

    #print(type(r))
    for i in range(K):
        b.append(r[i][1])
    return b
def average_temp(stations, names):
    r=0
    t=0
    for n in names:
        r =r+ stations[n]['temp']
        t=t+1
    return (r/t)




# --------------------------------------------------
# 6330452421 (30) 279 (2021-03-29 20:13)

def approx_match(stations, name):
    upname = name.upper()
    names = ""
    list_sta = []
    for e in upname:
        if e == " ":
            names+=""
        else:
            names+=e
    for k in stations:
        each_sta = ""
        for e in k:
            if e.upper() == " ":
                each_sta+=""
            else:
                each_sta+=e.upper()
        if names in each_sta:
            list_sta.append(k)
    return list_sta
def top_k_min_temp_stations(stations, K):
    ans =[]
    for e in stations:
        temp = stations[e]['temp']
        ans.append([temp,e])
    ans.sort()
    if len(ans) >= K:
        ans = ans[:K]
    top_sta =[]
    for a in ans:
        top_sta.append(a[1])
    return top_sta
def top_k_max_temp_stations(stations, K):
    ans =[]
    for e in stations:
        temp = stations[e]['temp']
        ans.append([temp,e])
    ans.sort(reverse=True)
    re_ans = [ans[0]]
    anss = []
    for i in range(len(ans)-1):
        if ans[i][0] != ans[i+1][0]:
            for e in re_ans:
                anss.append(e)
            re_ans=[ans[i+1]]
        else:
            re_ans.append(ans[i+1])
            re_ans.sort()
    if len(anss) >= K:
        anss = anss[:K]
    top_sta =[]
    for a in anss:
        top_sta.append(a[1])
    return top_sta
def peak_stations(stations):
    lat =[]
    for e in stations:
        l = stations[e]['lat']
        lat.append([l,e])
    long =[]
    for e in stations:
        l = stations[e]['long']
        long.append([l,e])
    lat.sort()
    long.sort()
    min_lat = lat[0][1]
    min_long = long[0][1]
    max_lat = lat[-1][1]
    max_long = long[-1][1]
    return [min_lat,max_lat,min_long,max_long]
def k_nearby_stations(stations, main_station, K):
    list_dis = []
    for e in stations:
        d=distance(stations[e]["lat"],stations[e]["long"],stations[main_station]["lat"],stations[main_station]["long"])
        list_dis.append([d,e])
    list_dis.sort()
    list_dis = list_dis[1:]
    if len(list_dis)>=K:
        ans = list_dis[:K]
    else:
        ans = list_dis
    answer = []
    for e in ans:
        answer.append(e[1])
    return answer
def average_temp(stations, names):
    sum = 0
    for e in names:
        sum+=stations[e]["temp"]
    aver_temp = sum/len(names)
    return aver_temp


# --------------------------------------------------
# 6330453021 (30) 280 (2021-03-26 22:43)

def approx_match(stations, name):
    name = name.upper()
    find_name = ''
    for i in name:
        if 'A' <= i <= 'Z':
            find_name += i
    x =[]
    provinces = []
    for i in stations:
        provinces.append(i.title().upper())
    provinces.sort()
    find_provinces = []
    for i in range(len(provinces)):
        closedpr = ''
        for k in provinces[i]:
            if 'A' <= k <= 'Z':
                closedpr += k
        find_provinces.append(closedpr)
    for i in range(len(provinces)):
        if find_name in (find_provinces[i]):
            x.append(provinces[i])
    return x
def top_k_min_temp_stations(stations, K):
    temp_inf = []
    for i in stations:
        temp_inf.append([stations[i]['temp'],i])
    temp_inf.sort()
    min_sta = []
    if K < len(stations):
        for i in range(K):
            min_sta.append(temp_inf[i][1])
    elif K > len(stations):
        for i in range(len(stations)):
            min_sta.append(temp_inf[i][1])
    return min_sta
def top_k_max_temp_stations(stations, K):
    temp_inf = []
    for i in stations:
        temp_inf.append([-stations[i]['temp'], i])
    temp_inf.sort()
    for i in range(len(temp_inf)):
        temp_inf[i][0] = temp_inf[i][0]*-1
    max_sta = []
    if K < len(stations):
        for i in range(K):
            max_sta.append(temp_inf[i][1])
    elif K > len(stations):
        for i in range(len(stations)):
            max_sta.append(temp_inf[i][1])
    return max_sta
def peak_stations(stations):
    lat_inf = []
    for i in stations:
        lat_inf.append([stations[i]['lat'],i])
    lat_inf.sort()
    long_inf = []
    for i in stations:
        long_inf.append([stations[i]['long'],i])
    long_inf.sort()
    peak = []
    peak.append(lat_inf[0][1])
    peak.append(lat_inf[-1][1])
    peak.append(long_inf[0][1])
    peak.append(long_inf[-1][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.lower()
    provinces = []
    for i in stations:
        provinces.append(i.title().lower())
    find_provinces = []
    for i in stations:
        find_provinces.append(i.title().upper())
    for i in range(len(provinces)):
        if main_station == provinces[i]:
            lat_main = stations[find_provinces[i]]['lat']
            long_main = stations[find_provinces[i]]['long']
    dis = []
    for i in stations:
        dis.append([distance(lat_main,long_main,stations[i]['lat'],stations[i]['long']),i])
    dis.sort()
    k_station = []
    if K < len(stations):
        for i in range(K):
            k_station.append(dis[i+1][1])
    elif K > len(stations):
        for i in range(len(stations)):
            k_station.append(dis[i+1][1])
    return k_station
def average_temp(stations, names):
    avg_temp = []
    sum = 0
    for i in range(len(names)):
        avg_temp.append(stations[names[i]]['temp'])
    for i in range(len(avg_temp)):
        sum += avg_temp[i]
    avg = sum / len(avg_temp)
    return avg
# --------------------------------------------------
# 6330454721 (28.74) 281 (2021-03-26 22:43)

def approx_match(stations, name):

    name = name.lower()
    x = ""
    for e in name :
        if "a" <= e <= "z" :
            x += e
    a = {}
    compare = []
    y = ""
    for key in stations :
        for e in key :
            if "a" <= e <= "z" or "A" <= e <= "Z" : y += e
        a[y.lower()] = key
        y = ""
    out = []
    for key in a :
        if x in key :
           out.append(a[key])
    return out
def top_k_min_temp_stations(stations, K):

    a = []
    for key in stations :
        a.append([stations[key]['temp'],key])
    a.sort()
    out = []
    if K > len(a) :
        for i in range(len(a)) :
            out.append(a[i][1])
    else :
        for i in range(K) :
            out.append(a[i][1])
    return out
def top_k_max_temp_stations(stations, K):

    a = []
    for key in stations :
        a.append([stations[key]['temp'],key])
    a.sort()
    b = a[-1::-1]
    out = []
    if K > len(b) :
        for i in range(len(b)) :
            out.append(b[i][1])
    else :
        for i in range(K) :
            out.append(b[i][1])
    return out
def peak_stations(stations):

    la = {}
    for key in stations :
        la[stations[key]['lat']] = key
    la_new = []
    for key in la :
        la_new.append([key,la[key]])
    la_new.sort()

    long = {}
    for key in stations :
        long[stations[key]['long']] = key
    long_new = []
    for key in long :
        long_new.append([key,long[key]])
    long_new.sort()
    return [la_new[0][1],la_new[-1][1],long_new[0][1],long_new[-1][1]]
def k_nearby_stations(stations, main_station, K):

    dis = {}
    for key in stations :
        d = distance(stations[main_station]['lat'],stations[main_station]['long'],stations[key]['lat'],stations[key]['long'])
        dis[d] = key
    a = []
    for key in dis :
        a.append([key,dis[key]])
    a.sort()
    b = a[1:]
    out = []
    if K > len(b) :
        for i in range(len(b)) :
            out.append(b[i][1])
    else :
        for i in range(K) :
            out.append(b[i][1])
    return out
def average_temp(stations, names):

    total = 0
    c = 0
    for e in names :
        if e in stations :
            total += stations[e]['temp']
            c += 1
    return total/c


# --------------------------------------------------
# 6330455321 (28.74) 282 (2021-03-26 22:52)

def approx_match(stations, name):
    a = []
    name2 = "".join(name.split())
    for i in stations :
        k = "".join(i.split())
        if k.find(name2.upper()) != -1 :
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for i in stations :
        a.append([stations[i]['temp'],i])
    a.sort()
    b = a[:K]
    c = []
    for i in b:
        c.append(i[1])
    return  c
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for i in stations :
        a.append([stations[i]['temp'],i])
    a.sort()
    b = a[-1:-K-1:-1]
    c = []
    for i in b:
        c.append(i[1])
    return  c
def peak_stations(stations):
    lon = []
    la = []
    for i in stations:
        lon.append([stations[i]['long'],i])
        la.append([stations[i]['lat'],i])
    lon.sort()
    la.sort()
    return [la[0][1],la[-1][1],lon[0][1],lon[-1][1]]
def k_nearby_stations(stations, main_station, K):
    d = []
    fin = []
    a = approx_match(stations,main_station)[0]

    for i in stations:
        d.append([distance(stations[i]['lat'],stations[i]['long'],stations[a]['lat'],stations[a]['long']),i])
    d.sort()
    c = []
    c = d[1:K+1]
    for i in c:
        fin.append(i[1])
    return fin
def average_temp(stations, names):
    avg = 0
    n = 0
    for i in names :
        avg += stations[i]['temp']
        n += 1
    return avg/n




# --------------------------------------------------
# 6330458221 (30) 283 (2021-03-27 12:59)

def approx_match(stations, name):

    ns = []
    for s in stations:
        ns.append(s)
    name = ''.join(name.upper().split())
    l = []
    for f in ns:
        if name in ''.join(f.split()):
            l.append(f)
    return l
def top_k_min_temp_stations(stations, K):

    st = []
    for f in stations:
        st.append([stations[f]['temp'],f])
    st.sort()
    l = []
    if K<=len(st):
        for i in range(K):
            l.append(st[i][1])
    else:
        for s in st:
            l.append(s[1])
    return l
def top_k_max_temp_stations(stations, K):

    st = []
    for f in stations:
        st.append([-stations[f]['temp'],f])
    st.sort()
    l = []
    if K<=len(st):
        for i in range(K):
            l.append(st[i][1])
    else:
        for s in st:
            l.append(s[1])
    return l
def peak_stations(stations):

    sla = []
    for f in stations:
        sla.append([stations[f]['lat'],f])
    sla.sort()
    minlat = sla[0][1]
    maxlat = sla[-1][1]
    slong = []
    for f in stations:
        slong.append([stations[f]['long'],f])
    slong.sort()
    minlong = slong[0][1]
    maxlong = slong[-1][1]
    return [minlat, maxlat, minlong, maxlong]
def k_nearby_stations(stations, main_station, K):

    sd = []
    for s in stations:
        if s!=main_station:
            sd.append([distance(stations[s]['lat'], stations[s]['long'], stations[main_station]['lat'], stations[main_station]['long']),s])
    sd.sort()
    l = []
    if K<=len(sd):
        for i in range(K):
            l.append(sd[i][1])
    else:
        for s in sd:
            l.append(s[1])
    return l
def average_temp(stations, names):

    s = 0
    for i in range(len(names)):
        s += stations[names[i]]['temp']
    return (s/len(names))

# --------------------------------------------------
# 6330459921 (30) 284 (2021-03-29 11:41)

def approx_match(stations, name):
    name = name.upper()
    s =[]
    new_name = ""
    for c in name :
        if c != " " :
            new_name += c
    for ch in stations :
        new_ch = ""
        for c in ch :
            if c != " " :
                c = c.upper()
                new_ch += c
        if new_name in new_ch :
            s.append(ch)
    return s
def top_k_min_temp_stations(stations, K):
    min1 = []
    for ch in stations :
        r = len(min1)
        st = stations[ch]["temp"]
        if r < K :
            min1.append([st,ch])
            min1.sort()
        else :
            for i in range(r) :
                if [st,ch] < min1[i] :
                    min1.insert(i,[st,ch])
                    min1.pop(-1)
                    break
    for i in range(len(min1)) :
        min1[i] = min1[i][1]

    return min1
def top_k_max_temp_stations(stations, K):
    max1 = []
    for ch in stations :
        r = len(max1)
        st = -stations[ch]["temp"]
        if r < K :
            max1.append([st,ch])
            max1.sort()
        else :
            for i in range(r) :
                if [st,ch] < max1[i] :
                    max1.insert(i,[st,ch])
                    max1.pop(-1)
                    break
    for i in range(len(max1)) :
        max1[i] = max1[i][1]

    return max1
def peak_stations(stations):
    s = []
    for ch in stations :
        r = len(s)
        lat = stations[ch]["lat"]
        long = stations[ch]["long"]
        lat_ch = [lat,ch]
        long_ch = [long,ch]
        if r == 0 :
            s =[lat_ch , lat_ch , long_ch , long_ch]
        else :
            if lat_ch < s[0] :
                s[0] = lat_ch
            if lat_ch > s[1] :
                s[1] = lat_ch
            if long_ch < s [2] :
                s[2] = long_ch
            if long_ch > s [3] :
                s[3] = long_ch
    for i in range(len(s)) :
        s[i] = s[i][1]

    return s
def k_nearby_stations(stations, main_station, K):
    s = []
    for ch in stations :
        lat1 = stations[ch]["lat"]
        long1 = stations[ch]["long"]
        lat2 = stations[main_station]["lat"]
        long2 = stations[main_station]["long"]
        d = distance(lat1 , long1 , lat2 , long2)
        if ch != main_station :
            if len(s) < K :
                s.append([d,ch])
                s.sort()
            else :
                for i in range(len(s)) :
                    if [d,ch] < s[i] :
                        s.insert(i,[d,ch])
                        s.pop(-1)
                        break
    for i in range(len(s)) :
        s[i] = s[i][1]

    return s
def average_temp(stations, names):
    s = 0
    for c in names :
        temp = stations[c]["temp"]
        s += temp
    avg = s/len(names)

    return avg


# --------------------------------------------------
# 6330460421 (30) 285 (2021-03-28 17:37)

def approx_match(stations, name):
    n = []
    ans = []
    a = ""
    name = name.upper()
    n = name.split(" ")
    for e in n:
        a += e
    for e in stations:
        if a in e.replace(" ","").upper():
            ans.append(e)
    return ans
def top_k_min_temp_stations(stations, K):
    statemp = []
    a = []
    for e in stations:
        statemp.append([stations[e]['temp'], e])
    statemp.sort()
    for i in range(min(K, len(stations))):
        a.append(statemp[i][1])
    return a
def top_k_max_temp_stations(stations, K):
    statemp = []
    a = []
    for e in stations:
        statemp.append([-stations[e]['temp'], e])
    statemp.sort()
    for i in range(min(K, len(stations))):
        a.append(statemp[i][1])
    return a
def peak_stations(stations):
    lat = []
    long = []
    latlong = []
    for e in stations:
        lat.append([stations[e]['lat'], e])
        lat.sort()
        long.append([stations[e]['long'], e])
        long.sort()
    latlong.append(lat[0][1])
    latlong.append(lat[-1][1])
    latlong.append(long[0][1])
    latlong.append(long[-1][1])
    return latlong
def k_nearby_stations(stations, main_station, K):
    a = []
    dis = []
    for e in stations:
        a.append([distance(stations[e]['lat'], stations[e]['long'], stations[main_station]['lat'], stations[main_station]['long']), e])
        a.sort()
    a = a[1:]
    for i in range(min(K, len(stations))):
        dis.append(a[i][1])
    return dis
def average_temp(stations, names):
    n = 0
    for e in names:
        n += stations[e]['temp']
    return n / len(names)


# --------------------------------------------------
# 6330461021 (30) 286 (2021-03-29 23:45)

def approx_match(stations, name):
    a = []
    b = ""
    for e in name.lower():
        if e != " ":
            b += e.lower()
    for k in stations:
        if b in k.lower():
            a.append(k.upper())
    return a
def top_k_min_temp_stations(stations, K):
    p = []
    n = []
    for k in stations:
        p.append([stations[k]['temp'],k])
    p.sort()
    if K >= len(p):
        for e in range(len(p)):
            n.append(p[e][1])
    else:
        for e in range(K):
            n.append(p[e][1])
    return n
def top_k_max_temp_stations(stations, K):
    p = []
    n = []
    for k in stations:
        p.append([-1*(stations[k]['temp']),k])
    p.sort()
    if K >= len(p):
        for e in range(len(p)):
            n.append(p[e][1])
    else:
        for e in range(K):
            n.append(p[e][1])
    return n
def peak_stations(stations):
    lat_n = []
    long_n = []
    ans = []
    for k in stations:
        lat_n.append([stations[k]['lat'],k])
        long_n.append([stations[k]['long'],k])
    lat_n.sort()
    long_n.sort()
    ans.append(lat_n[0][1])
    ans.append(lat_n[-1][1])
    ans.append(long_n[0][1])
    ans.append(long_n[-1][1])
    return ans
def k_nearby_stations(stations, main_station, K):
    u = main_station.upper()
    interest = [u,stations[u]]
    d = []
    s = []
    for k in stations:
        d.append([distance(interest[1]['lat'],interest[1]['long'],stations[k]['lat'],stations[k]['long']),k])
    d.sort()
    if K <= len(d):
        for i in range(1,K+1):
            s.append(d[i][1])
    else:
        for i in range(1,len(d)):
            s.append(d[i][1])
    return s
def average_temp(stations, names):
    t = []
    sum = 0
    for e in names:
        t.append(stations[e]['temp'])
    for e in t:
        sum += e
    avg = sum/len(t)
    return avg

# --------------------------------------------------
# 6330462721 (30) 287 (2021-03-29 22:16)

def approx_match(stations, name):

    new = "" ; lists = []
    up = name.upper()
    for n in up:
        if n == " ":
            pass
        else :
            new += n

    for s in stations :
        st = ""
        t = s.upper()
        for ch in t:
            if ch == " ":
                pass
            else :
                st += ch

        if new in st:
            lists.append(s)

    return lists
def top_k_min_temp_stations(stations, K):

    pre = [] ; lists = []
    for s in stations :
        pre.append([stations[s]["temp"],s])
    pre.sort()
    pre = pre[:K:]
    for p in pre :
        lists.append(p[1])

    return lists
def top_k_max_temp_stations(stations, K):

    pre = [] ; lists = []
    for s in stations :
        pre.append([-stations[s]["temp"],s])
    pre.sort()
    pre = pre[:K:]
    for p in pre :
        lists.append(p[1])

    return lists
def peak_stations(stations):

    peak = [] ; lat = [] ; long = []
    for s in stations :
        lat.append([stations[s]["lat"],s])
        long.append([stations[s]["long"],s])

    lat.sort() ; long.sort()

    peak.append(lat[0][1])
    peak.append(lat[-1][1])
    peak.append(long[0][1])
    peak.append(long[-1][1])

    return peak
def k_nearby_stations(stations, main_station, K):

    near = [] ; nearby = [] ; main = []

    if main_station in stations :
        main.append(stations[main_station]["lat"])
        main.append(stations[main_station]["long"])

    for s in stations :
        if s != main_station :
            d = distance(main[0],main[1],stations[s]["lat"],stations[s]["long"])
            near.append([d,s])
    near.sort()
    near = near[:K:]
    for n in near :
        nearby.append(n[1])

    return nearby
def average_temp(stations, names):

    temp = 0
    for n in names :
        if n in stations:
            temp += stations[n]["temp"]
    avg = temp/len(names)

    return avg


# --------------------------------------------------
# 6330463321 (30) 288 (2021-03-29 00:16)

def approx_match(stations, name):
    l = []
    im_name = ''
    for e in name.upper():
        if 'A' <= e <= 'Z' or 'a' <= e <= 'z':
            im_name += e
    for e in stations:
        if im_name in e.upper():
            l.append(e)
    return l
def top_k_min_temp_stations(stations, K):
    min_temp = []
    re_mintemp = []
    return_mintemp = []
    for e in stations:
        min_temp.append([stations[e]['temp'],e])
    min_temp.sort()
    re_mintemp += min_temp[:K]
    for e in re_mintemp:
        return_mintemp.append(e[1])
    return return_mintemp
def top_k_max_temp_stations(stations, K):
    max_temp = []
    re_maxtemp = []
    return_maxtemp = []
    for e in stations:
        max_temp.append([-stations[e]['temp'],e])
    max_temp.sort()
    re_maxtemp += max_temp[:K]
    for e in re_maxtemp:
        return_maxtemp.append(e[1])
    return return_maxtemp
def peak_stations(stations):
    l_lat = []
    l_long = []
    for e in stations:
        l_lat.append([stations[e]['lat'],e])
        l_long.append([stations[e]['long'],e])
    l_lat.sort()
    l_long.sort()

    return [l_lat[0][1],l_lat[-1][1],l_long[0][1],l_long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    dis = []
    for e in stations :
        if e != main_station:
            dis.append([distance(stations[main_station.upper()]['lat'],stations[main_station.upper()]['long'], \
                                stations[e]['lat'],stations[e]['long']),e])
    dis.sort()
    name_near = []
    for i in range(K):
        name_near.append(dis[i][1])
    return name_near
def average_temp(stations, names):
    aver_temp = 0
    for e in names:
        aver_temp += stations[e]['temp']
    aver_temp /= len(names)
    return aver_temp



# --------------------------------------------------
# 6330464021 (28.14) 289 (2021-03-29 15:11)

def approx_match(stations, name):
    name=name.replace(' ','').upper()
    c=[]
    for e in stations:
        if name in e.replace(' ','').upper():
            c.append(e)
    return c
def top_k_min_temp_stations(stations, K):
    t=[];d=[]
    for e in stations:
        t.append([stations[e]['temp'],e])
    t.sort()
    for i in range(K):
        d.append(t[i][1])
    return d
def top_k_max_temp_stations(stations, K):
    t=[];d=[]
    for e in stations:
        t.append([stations[e]['temp'],e])
    t.sort()
    for i in range(K):
        d.append(t[-i-1][1])
    return d
def peak_stations(stations):
    lat=[];long=[]
    for e in stations:
         lat.append([stations[e]['lat'],e])
         long.append([stations[e]['long'],e])
    lat.sort();long.sort()
    return lat[0][1], lat[-1][1], long[0][1], long[-1][1]
def k_nearby_stations(stations, main_station, K):
    d=[];f=[]
    for e in stations:
        d.append([distance(stations[e]['lat'],stations[e]['long'],stations[approx_match(stations,main_station)[0]]['lat'],stations[approx_match(stations,main_station)[0]]['long']),e])
    d.sort()
    d.remove(d[0])
    for i in range(K):
        f.append(d[i][1])
    return f
def average_temp(stations, names):
    a=0
    n=0
    for e in names:
        a+=stations[e]['temp']
        n+=1
    return a/n


# --------------------------------------------------
# 6330465621 (29.49) 290 (2021-03-29 16:02)

def approx_match(stations, name):
    pv = []
    name2 = ''
    for i in name :
        if "A" <= i <= "Z" or "a" <= i <= "z" :
            name2 += i.upper()
    for e in stations :
        name_test = ''
        for a in e :
            if a != ' ' :
                name_test += a
        if name2 in name_test :
            pv.append(e)
    return pv
def top_k_min_temp_stations(stations, K):
    pv = []
    station_return = []
    for e in stations :
        pv.append([stations[e]['temp'],e])
    pv.sort()
    if K <= len(pv) :
        for i in range(K) :
            station_return.append(pv[i][1])
    else :
        for j in pv :
            station_return.append(j[1])
    return station_return
def top_k_max_temp_stations(stations, K):
    pv = []
    station_return = []
    for e in stations :
        pv.append([stations[e]['temp'],e])
    pv.sort()
    pv2 = []
    for k in range(len(pv)) :
        if pv[k][0] == pv[k-1][0] and k != 0 :
            pv2.append(pv[k])
        else :
            pv2.insert(0,pv[k])
    if K <= len(pv2) :
        for i in range(K) :
            station_return.append(pv2[i][1])
    else :
        for j in pv2 :
            station_return.append(j[1])
    return station_return
def peak_stations(stations):
    pv_long = []
    pv_lat = []
    for e in stations :
        pv_long.append([stations[e]['long'],e])
        pv_lat.append([stations[e]['lat'],e])
    pv_long.sort()
    pv_lat.sort()
    info = [ pv_lat[0][1] , pv_lat[-1][1] , pv_long[0][1] , pv_long[-1][1] ]
    return info
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    pv_dist = []
    dist = []
    for e in stations :
        if e != main_station :
            lat2 = stations[e]['lat']
            long2 = stations[e]['long']
            dist.append([distance(lat1,long1,lat2,long2),e])
    dist.sort()
    if K <= len(dist) :
        for i in range(K) :
            pv_dist.append(dist[i][1])
    else :
        for j in dist :
            pv_dist.append(j[1])
    return pv_dist
def average_temp(stations, names):
    temp = []
    for e in names :
        temp.append(stations[e]['temp'])
    temp_averange = sum(temp) / len(temp)
    return temp_averange

# --------------------------------------------------
# 6330466221 (30) 291 (2021-03-29 22:46)

def approx_match(stations, name):
    new = ''
    for i in range(len(name)):
        if name[i] in alp:
            new += name[i]
        else:
            new += ''
    new = new.upper()
    ans = []
    for i in stations:
        if new in i:
            ans.append(i)
    return ans
def top_k_min_temp_stations(stations, K):
    ans = []
    sta = stations
    staa = {k: v for k, v in sorted(sta.items(), key=lambda item: item[1]['temp'])}
    d = 0
    if K > len(staa):
        K = len(staa)
    for i in staa:
        ans.append(i)
        d += 1
        if d == K:
            break
    return ans
def top_k_max_temp_stations(stations, K):
    ans = []
    new = []
    for i in stations:
        new.append([-(stations[i]['temp']),i])
    new.sort()
    d = 0
    if K > len(new):
        K = len(new)
    for i in new:
        ans.append(i[1])
        d += 1
        if d == K:
            break
    return ans
def peak_stations(stations):
    lat = []
    long = []
    stationss = []
    ans = []
    for i in stations:
        stationss.append(i)
        lat.append(stations[str(i)]['lat'])
        long.append(stations[str(i)]['long'])
    ans.append(stationss[lat.index(min(lat))])
    ans.append(stationss[lat.index(max(lat))])
    ans.append(stationss[long.index(min(long))])
    ans.append(stationss[long.index(max(long))])
    return ans
def k_nearby_stations(stations, main_station, K):
    dis = []
    LAT = stations[main_station]['lat']
    LONG = stations[main_station]['long']
    sta = stations
    staa = {k: v for k, v in sorted(sta.items(), key=lambda item: distance(LAT,LONG,item[1]['lat'],item[1]['long']))}
    d = 0
    for i in staa:
        dis.append(i)
        d += 1
        if d == K+1:
            break
    dis.pop(0)
    return dis
def average_temp(stations, names):
    tot = 0
    n = 0
    for i in names:
        tot += stations[i]['temp']
        n += 1
    ans = tot/n
    return ans


# --------------------------------------------------
# 6330467921 (28.74) 292 (2021-03-29 20:00)

def approx_match(stations, name):
    name = name.upper()
    n = ''
    for i in name:
        if 'A' <= i <= 'Z':
            n += i
    approx = []
    for key in stations:
        k = ''
        for a in key:
            if 'A' <= a.upper() <= 'Z':
                k += a
        if n in k.upper():
            approx.append(key)
    return approx
def top_k_min_temp_stations(stations, K):
    templist = []
    for key in stations:
        templist.append([stations[key]['temp'],key])
    templist.sort()
    templist = templist[:K]
    topmin = []
    for i in range(len(templist)):
        topmin.append(templist[i][1])
    return topmin
def top_k_max_temp_stations(stations, K):
    templist = []
    for key in stations:
        templist.append([stations[key]['temp'],key])
    templist.sort()
    templist = templist[::-1]
    templist = templist[:K]
    topmax = []
    for i in range(len(templist)):
        topmax.append(templist[i][1])
    return topmax
def peak_stations(stations):
    latlist = []
    longlist = []
    for key in stations:
        latlist.append([stations[key]['lat'],key])
        longlist.append([stations[key]['long'],key])
    minlat = min(latlist)
    maxlat = max(latlist)
    minlong = min(longlist)
    maxlong = max(longlist)
    peak = [minlat[1], maxlat[1], minlong[1], maxlong[1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    mainlat = stations[main_station]['lat']
    mainlong = stations[main_station]['long']
    distancelist = []
    for station in stations:
        lat = stations[station]['lat']
        long = stations[station]['long']
        d = distance(mainlat,mainlong,lat,long)
        if d != 0:
            distancelist.append([d,station])
    distancelist.sort()
    distancelist = distancelist[:K]
    nearest = []
    for i in range(len(distancelist)):
        nearest.append(distancelist[i][1])
    return nearest
def average_temp(stations, names):
    sumtemp = 0
    for name in names:
        if name in stations:
            sumtemp += stations[name]['temp']
    avtemp = sumtemp / len(names)
    return avtemp



# --------------------------------------------------
# 6330468521 (29.6) 293 (2021-03-29 19:38)

def approx_match(stations, name):
    stations_d = { }
    for k in stations :
        sl = ""
        for e in k :
            if e == " " :
                sl += ""
            else :
                sl += e
        stations_d[sl] = k
    n = ""
    for e in name :
        if e == " " :
            n += ""
        else :
            n += e.upper()
    stations_r = []
    for k in stations_d :
        if n in k :
            stations_r.append(stations_d[k])
    return stations_r
def top_k_min_temp_stations(stations, K):
    stations_temp_list = []
    for k in stations :
        stations_temp_list.append([stations[k]["temp"],k])
    stations_temp_list.sort()
    stations_tmin_k = []
    if len(stations_temp_list) >= K :
        for i in range(K) :
            stations_tmin_k.append(stations_temp_list[i][1])
    else :
        for i in range(len(stations_temp_list)) :
            stations_tmin_k.append(stations_temp_list[i][1])
    return stations_tmin_k
def top_k_max_temp_stations(stations, K):
    stations_temp_list = []
    for k in stations :
        stations_temp_list.append([-stations[k]["temp"],k])
    stations_temp_list.sort()
    stations_tmax_k = []
    if len(stations_temp_list) >= K :
        for i in range(K) :
            stations_tmax_k.append(stations_temp_list[i][1])
    else :
        for i in range(len(stations_temp_list)) :
            stations_tmax_k.append(stations_temp_list[i][1])
    return stations_tmax_k
def peak_stations(stations):
    lat = []
    long = []
    for k in stations :
        lat.append([stations[k]["lat"],k])
        long.append([stations[k]["long"],k])
    lat.sort()
    long.sort()
    lat_min = lat[0][1]
    lat_max = lat[-1][1]
    long_min = long[0][1]
    long_max = long[-1][1]
    return lat_min, lat_max, long_min, long_max
def k_nearby_stations(stations, main_station, K):
    lat1 = float(stations[main_station]["lat"])
    long1 = float(stations[main_station]["long"])
    distance_list = []
    for k in stations :
        if k != main_station :
            lat2 = float(stations[k]["lat"])
            long2 = float(stations[k]["long"])
            d = distance(lat1, long1, lat2, long2)
            distance_list.append([d, k])
    distance_list.sort()
    nearby_stations = []
    if len(distance_list) >= K :
        for i in range(K) :
            nearby_stations.append(distance_list[i][1])
    else :
        for i in range(len(distance_list)) :
            nearby_stations.append(distance_list[i][1])
    return nearby_stations
def average_temp(stations, names):
    temp = []
    for k in stations :
        for i in range(len(names)) :
            if k == names[i] :
                temp.append(stations[k]["temp"])
    s = 0
    for i in range(len(temp)) :
        s += float(temp[i])
    average = s / len(temp)
    return average

# --------------------------------------------------
# 6330469121 (28.14) 294 (2021-03-29 15:12)

def approx_match(stations, name):
    name=name.upper()
    show=[]
    name1=''
    name3=''
    for i in name :
        if 'A'<=i<='Z':
            name1+=i
    for key in stations :
        name2=''
        for e in key:
            if 'A'<=e<='Z':
                name2+=e
        if name1 in name2:
            show.append(key)
    return show
def top_k_min_temp_stations(stations, K):
    a=[]
    for x in stations:
        a.append([stations[x]['temp'],x])
    a.sort()
    b=[]
    c=[]
    if K>=len(a):
        for i in range(len(a)):
            b.append(a[i][1])
        return b
    else:
        for i in range(K):
            c.append(a[i][1])
        return c
def top_k_max_temp_stations(stations, K):
    a=[]
    for x in stations:
        a.append([stations[x]['temp'],x])
    a.sort()
    a=a[::-1]
    b=[]
    c=[]
    if K>=len(a):
        for i in range(len(a)):
            b.append(a[i][1])
        return b
    else:
        for i in range(K):
            c.append(a[i][1])
        return c
def peak_stations(stations):
    a=stations
    x=[]
    y=[]
    for e in a:
        x.append([stations[e]['lat'],e])
        y.append([stations[e]['long'],e])
        mi1=min(x)
        mi1=mi1[1]
        mi2=min(y)
        mi2=mi2[1]
        ma1=max(x)
        ma1=ma1[1]
        ma2=max(y)
        ma2=ma2[1]
    return mi1,ma1,mi2,ma2
def k_nearby_stations(stations, main_station, K):
    q=[]
    b=[]
    c=[]
    for e in stations:
        a=[distance(stations[e]['lat'], stations[e]['long'], stations[main_station]['lat'], stations[main_station]['long']),e]
        if a[0]!=0:
            q.append(a)
    q.sort()
    if K>=len(q):
        for i in range(len(q)):
            b.append(q[i][1])
        return b
    else:
        for i in range(K):
            c.append(q[i][1])
        return c
def average_temp(stations, names):
    q=0
    for e in names:
        q+=int(stations[e]['temp'])
    return  q/len(names)



# --------------------------------------------------
# 6330470721 (28.74) 295 (2021-03-28 01:20)

def approx_match(stations, name):
    n = ''
    for i in range(len(name)):
        if 'A'<= name[i] <='Z' or 'a'<= name[i] <='z':
            n+=name[i]
    n=n.upper()
    namae = []
    for a in stations:
        if n in a:
            namae.append(a)
    return namae
def top_k_min_temp_stations(stations, K):
    temp_list=[]
    station_list1=[]
    for i in stations:
        station_min=[stations[i]['temp'],i]
        temp_list.append(station_min)
    temp_list.sort()
    for j in range(int(K)):
        station_list1.append(temp_list[j][1])
    return station_list1
def top_k_max_temp_stations(stations, K):
    temp_list=[]
    station_list2=[]
    for i in stations:
        station_min=[stations[i]['temp'],i]
        temp_list.append(station_min)
    temp_list.sort()
    for j in range(1,int(K)+1):
        station_list2.append(temp_list[-j][1])
    return station_list2
def peak_stations(stations):
    point_list_lat=[]
    point_list_long=[]
    station_list3=[]
    for i in stations:
        station_lat=[stations[i]['lat'],i]
        point_list_lat.append(station_lat)
    point_list_lat.sort()
    for j in stations:
        station_long=[stations[j]['long'],j]
        point_list_long.append(station_long)
    point_list_long.sort()
    station_list3.append(point_list_lat[0][1])
    station_list3.append(point_list_lat[-1][1])
    station_list3.append(point_list_long[0][1])
    station_list3.append(point_list_long[-1][1])
    return station_list3
def k_nearby_stations(stations, main_station, K):
    main_station=main_station.upper()
    nearby_list=[]
    station_list4=[]
    for i in stations:
        x=distance(stations[i]['lat'], stations[i]['long'], stations[main_station]['lat'], stations[main_station]['long'])
        nearby_list.append([x,i])
    nearby_list.sort()
    for j in range(1,K+1):
        station_list4.append(nearby_list[j][1])
    return station_list4
def average_temp(stations, names):
    temper_list=[]
    avg=0
    for i in names:
        if i in stations:
            temper_list.append(stations[i]['temp'])
    for j in range(len(temper_list)):
        avg+=temper_list[j]
    print(temper_list)
    return avg/len(temper_list)


# --------------------------------------------------
# 6330471321 (19.98) 296 (2021-03-29 09:02)

def approx_match(stations, name):
    x = stations.keys()
    y = []

    for i in x:
        if name.lower() in i.lower().replace(' ', ''):
            y.append(i)
    return y
def top_k_min_temp_stations(stations, K):
    x = sorted(stations.items(), key=lambda item: item[0])
    x = sorted ( x, key = lambda y : y[1]['temp'] )
    x = list ( map ( lambda y : y[0], x ) ) [0:K]
    return x
def top_k_max_temp_stations(stations, K):
    x = sorted(stations.items(), key=lambda item: item[0])  [::-1]
    x = sorted ( x, key = lambda y : y[1]['temp'] ) [::-1]
    x = list ( map ( lambda y : y[0], x ) ) [0:K]
    return x
def peak_stations(stations):
    lat_max = sorted(stations.items(), key=lambda item: item[0])  [::-1]
    lat_max = sorted ( lat_max, key = lambda y : y[1]['lat'] ) [::-1]
    lat_max = list ( map ( lambda y : y[0], lat_max ) ) [0]
    long_max = sorted(stations.items(), key=lambda item: item[0])  [::-1]
    long_max = sorted ( long_max, key = lambda y : y[1]['long'] ) [::-1]
    long_max = list ( map ( lambda y : y[0], long_max ) ) [0]
    lat_min = sorted(stations.items(), key=lambda item: item[0])
    lat_min = sorted ( lat_min, key = lambda y : y[1]['lat'] )
    lat_min = list ( map ( lambda y : y[0], lat_min ) ) [0]
    long_min = sorted(stations.items(), key=lambda item: item[0])
    long_min = sorted ( long_min, key = lambda y : y[1]['long'] )
    long_min = list ( map ( lambda y : y[0], long_min ) ) [0]
    return [lat_min,lat_max,long_min,long_max]
def k_nearby_stations(stations, main_station, K):
    x = stations.items()
    y = map( lambda y : [y[0], y[1]['lat'],y[1]['long']], x)
    y.sort(key = lambda y : y[0])
    main = [stations[main_stations]['lat'],stations[main_stations]['long']]
    z = map( lambda y : [y[0], distance(main[0],main[1],y[1],y[2])], y)
    z.sort(key = lambda y : y[1])
    return list(map( lambda y : y[0], z))[1 : K+1]
def average_temp(stations, names):
    x = list(map(lambda y : stations[y]['temp'], names))
    z = 0
    for i in x:
        z += i
    avg = z/len(x)
    return round(avg, 1)





# --------------------------------------------------
# 6330472021 (29.25) 297 (2021-03-29 22:10)

def approx_match(stations, name):
    x= name.upper()
    n=''
    for i in range(len(x)):
        if 'A' <= x[i] <= 'Z':
            n += (x[i])
    am =[]
    for e in stations:
        u=''
        for i in range(len(e)):
            if 'A' <= e[i] <= 'Z':
                u += (e[i])
        if n in u:
            am.append(e)
    return am
def top_k_min_temp_stations(stations, K):
    d=[]
    f=[]
    for e in stations:
        u = [stations[e]['temp'],e]
        d.append(u)
    d.sort()
    if K > len(d):
        K = len(d)
    for i in range(K):
        f.append(d[i][1])

    return f
def top_k_max_temp_stations(stations, K):
    d=[]
    f=[]
    for e in stations:
        u = [stations[e]['temp'],e]
        d.append(u)
    d.sort()
    u=d[::-1]
    r=u[:K:]
    if K > len(r):
        K=len(r)
    p = [r[0][1]]
    for i in range(K-1):
        if r[i][0] == r[i+1][0]:
            p.insert(p.index(r[i][1]),r[i+1][1])
        else:
            p.append(r[i+1][1])
    return p
def peak_stations(stations):
    la=[]
    lo=[]
    for e in stations:
        u = [stations[e]['lat'],e]
        la.append(u)
        v = [stations[e]['long'],e]
        lo.append(v)
    la.sort()
    lo.sort()
    peak = [la[0][1] , la[len(la)-1][1] , lo[0][1] , lo[len(lo)-1][1] ]
    return peak
def k_nearby_stations(stations, main_station, K):
    a=[]
    b=[]
    for e in stations:
        d = distance(stations[main_station]['lat'],stations[main_station]['long'],stations[e]['lat'],stations[e]['long'])
        u = [d,e]
        a.append(u)
    a.sort()
    if K > len(a):
        K=len(a)
    for i in range(K):
        b.append(a[i+1][1])
    return b
def average_temp(stations, names):
    sum = 0
    for e in names:
        sum += float(stations[e]['temp'])
    return sum/len(names)




# --------------------------------------------------
# 6330474221 (30) 298 (2021-03-29 23:54)

def approx_match(stations, name):

    name = name.replace(" ","").lower()
    names = []
    for station in stations.keys():
        if name in station.lower().replace(' ',''):
            names.append(station)

    return names
def top_k_min_temp_stations(stations, K):
    names = []
    sorted_list = sorted(stations.items(), key = lambda item:(item[1]['temp'],item[0]))

    if K > len(sorted_list):
        K = len(sorted_list)

    for i in range(K):
        names.append(sorted_list[i][0])

    return names
def top_k_max_temp_stations(stations, K):
    names = []
    sorted_list = sorted(stations.items(), key = lambda item:(-item[1]['temp'],item[0]))

    if K > len(sorted_list):
        K = len(sorted_list)

    for i in range(K):
        names.append(sorted_list[i][0])

    return names
def peak_stations(stations):
    names = []
    min_lat = min(stations.items(), key = lambda item:item[1]['lat'])
    max_lat = max(stations.items(), key = lambda item:item[1]['lat'])
    min_long = min(stations.items(), key = lambda item:item[1]['long'])
    max_long = max(stations.items(), key = lambda item:item[1]['long'])


    names.append(min_lat[0])
    names.append(max_lat[0])
    names.append(min_long[0])
    names.append(max_long[0])

    return names
def k_nearby_stations(stations, main_station, K):
    main_lat = stations[main_station]['lat']
    main_long = stations[main_station]['long']
    distance_dict = {}

    for station in stations.keys():
        if station != main_station:
            station_lat = stations[station]['lat']
            station_long = stations[station]['long']
            station_distance = distance(main_lat, main_long,station_lat, station_long)

            distance_dict[station] = station_distance
    names = []
    sorted_list = sorted(distance_dict.items(), key=lambda item: item[1])

    if K > len(sorted_list):
        K = len(sorted_list)

    for i in range(K):
        names.append(sorted_list[i][0])

    return names
def average_temp(stations, names):
    sum_temp = 0.0
    c=0

    for name in names:
        if name in stations :
            c=c+1
            temp = stations[name]['temp']
        sum_temp += temp

    return sum_temp/c




# --------------------------------------------------
# 6330475921 (30) 299 (2021-03-29 16:28)

def approx_match(stations, name):
    st=""
    for e in name.lower():
        if e != " ":
            st+=e
    st_li = list()
    for nam in stations:
        ful_na = ''
        for e in nam.lower():
            if e != ' ':
                ful_na += e
        if st in ful_na:
            st_li.append(nam)
    return st_li
def top_k_min_temp_stations(stations, K):
    top_k = []
    for name in stations:
        tem = stations[name]['temp']
        na_st = name
        top_k.append([tem, na_st])
    top_k.sort()
    top_k = top_k[:K]
    fin_top_k = [nam for tem,nam in top_k]
    return fin_top_k
def top_k_max_temp_stations(stations, K):
    top_k = []
    for name in stations:
        tem = stations[name]['temp']
        na_st = name
        top_k.append([tem*-1, na_st])
    top_k.sort()
    top_k = top_k[:K]
    fin_top_k = [nam for tem,nam in top_k]
    return fin_top_k
def peak_stations(stations):
    top_lat = []
    top_long = []
    for nam in stations:
        top_lat.append([stations[nam]['lat'], nam])
        top_long.append([stations[nam]['long'], nam])
    top_lat.sort()
    top_long.sort()
    fin_peak = []
    fin_peak.append(top_lat[0][1])
    fin_peak.append(top_lat[-1][1])
    fin_peak.append(top_long[0][1])
    fin_peak.append(top_long[-1][1])
    return fin_peak
def k_nearby_stations(stations, main_station, K):
    top_nea = []
    for nam in stations:
        if nam != main_station:
            lat_1 = stations[nam]['lat']
            lat_2 = stations[main_station]['lat']
            long_1 = stations[nam]['long']
            long_2 = stations[main_station]['long']
            distan = distance(lat_1, long_1, lat_2, long_2)
            top_nea.append([distan, nam])
    top_nea.sort()
    fin_nea = []
    for i in range(K):
        fin_nea.append(top_nea[i][1])
    return fin_nea
def average_temp(stations, names):
    tem_tot = []
    for e in names:
        tem_tot.append(stations[e]['temp'])
    ave_tem_st = sum(tem_tot)/len(names)
    return  ave_tem_st

# --------------------------------------------------
# 6330476521 (28.02) 300 (2021-03-29 12:40)

def approx_match(stations, name):
    names = []
    named = ''
    for ch in name:
        if ch != ' ':
            named += ch.upper()
    for sn in stations:
        n = ''
        for ch in sn:
            if ch != ' ':
                n += ch.upper()
        if named in n:
            names.append(sn)
    return names
def top_k_min_temp_stations(stations, K):
    temp = []
    names = []
    for name in stations:
        temp.append(stations[name]['temp'])
    temp.sort()
    for i in range(K):
        for name in stations:
            if stations[name]['temp'] == temp[i]:
                names.append(name)
    names.sort()
    return names
def top_k_max_temp_stations(stations, K):
    temp = []
    names = []
    for name in stations:
        temp.append(stations[name]['temp'])
    temp.sort(reverse = True)
    for i in range(K):
        for name in stations:
            if stations[name]['temp'] == temp[i]:
                names.append(name)
    names.sort()
    return names
def peak_stations(stations):
    lati = []
    longi = []
    names = [0]*4
    for name in stations:
        lati.append(stations[name]['lat'])
        longi.append(stations[name]['long'])
    lati.sort()
    longi.sort()
    for name in stations:
        if stations[name]['lat'] == lati[0]:
            names[0] = name
        elif stations[name]['lat'] == lati[-1]:
            names[1] = name
        elif stations[name]['long'] == longi[0]:
            names[2] = name
        elif stations[name]['long'] == longi[-1]:
            names[3] = name
    return names
def k_nearby_stations(stations, main_station, K):
    names = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    distances = {}
    d = []
    for name in stations:
        lat2 = stations[name]['lat']
        long2 = stations[name]['long']
        distances[name] = distance(lat1, long1, lat2, long2)
        d.append(distance(lat1, long1, lat2, long2))
    d.sort()
    for i in range(K+1):
        for name in distances:
            if name != main_station and distances[name] == d[i]:
                names.append(name)
    return names
def average_temp(stations, names):
    total = 0
    for name in names:
        total += stations[name]['temp']
    return total / len(names)


# --------------------------------------------------
# 6330477121 (22) 301 (2021-03-29 22:54)

def approx_match(stations, name):
    Ans = []
    Space = ''
    Count = 0

    for i in name:
        if i != ' ':
            Space += i.upper()
        else:
            Count += 1
            pass

    for j in stations:
        Space2 = ''

        for i in j:
            if i != ' ':
                Space2 += i.upper()

            else:
                pass

        if Space in Space2:
            Ans.append(j)

        else:
            pass

    return Ans
def top_k_min_temp_stations(stations, K):
    Ans = []
    Count = 0
    for k in stations:
        if len(Ans) >= K:
            for i in range(len(r)):
                 if [stations[k]['temp'], k] < Ans[i]:
                    Ans.insert(i, [stations[k]['temp'], k])
                    Ans.pop(-1)
                    Count += 1
                    break

                 else:
                    pass

        else:
            Ans.append([stations[k]['temp'], k])
            Ans.sort()
            Count = Count


    for i in range(len(Ans)):
        Ans[i] = Ans[i][1]

    return Ans
def top_k_max_temp_stations(stations, K):
    Ans = []
    Count = 0

    for k in stations:
        if len(Ans) >= K:
            for i in range(len(Ans)):
                if [-stations[k]['temp'], k] < Ans[i]:
                    Ans.insert(i, [-stations[k]['temp'], k])
                    Ans.pop(-1)
                    Count += 1
                    break

                else:
                    pass
        else:
            Ans.append([-stations[k]['temp'], k])
            Ans.sort()

    for i in range(len(Ans)):
        Ans[i] = Ans[i][1]

    return Ans
def peak_stations(stations):
    Ans = []
    Count = 0
    for k in stations:
        if len(Ans) != 0:
            if [stations[k]['lat'], k] < Ans[0]:
                Ans[0] == [stations[k]['lat'], k]
            if [stations[k]['lat'], k] > Ans[1]:
                Ans[1] == [stations[k]['lat'], k]
            if [stations[k]['long'], k] < Ans[2]:
                Ans[2] == [stations[k]['long'], k]
            if [stations[k]['long'], k] > Ans[3]:
                Ans[3] == [stations[k]['long'], k]
        else:
            Ans = [[stations[k]['lat'], k], [stations[k]['lat'], k], [stations[k]['long'], k], [stations[k]['long'], k]]

        Count += 1

    for i in range(len(Ans)):
        Ans[i] = Ans[i][1]

    return Ans
def k_nearby_stations(stations, main_station, K):
    Ans = []
    Count = 0
    for k in stations:
        if k != main_station:
            if len(Ans) >= K:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                for i in range(len(Ans)):
                    if [d, k] < Ans[i]:
                        Ans.insert(i, [d, k])
                        Ans.pop(-1)
                        Count += 1
                        break
                    else:
                        pass
            else:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                Ans.append([d, k])
                Ans.sort()
                Count = Count
        else:
            pass

    for i in range(len(Ans)):
        Ans[i] = Ans[i][1]

    return Ans
def average_temp(stations, names):
    Ans = 0
    for n in names:
        Ans += stations[n]['temp']

    return Ans / len(names)


# --------------------------------------------------
# 6330478821 (30) 302 (2021-03-29 22:05)

def approx_match(stations, name):
    alpha=name.upper()
    a=''
    b=[]

    for i in range(len(alpha)):
        if alpha[i]==' ':
            a+=''
        else:
            a+=alpha[i]
    for e in stations:
        c=''
        m=e.upper()
        for j in range(len(m)):
            if m[j]!=' ':
                c+=m[j]

        if a in c:
            b.append(e)
    return b
def top_k_min_temp_stations(stations, K):
    a=[]
    for k in stations:
        a.append([stations[k]['temp'],k])
    a.sort()
    b=a[0:K]
    c=[]
    for j in range(len(b)):
        c.append(b[j][1])
    return c
def top_k_max_temp_stations(stations, K):
    a=[]
    for k in stations:
        a.append([-stations[k]['temp'],k])
    a.sort()
    b=a[0:K]
    c=[]
    for j in range(len(b)):
        c.append(b[j][1])
    return c
def peak_stations(stations):
    a=[]
    b=[]

    for i in stations:
        a.append([stations[i]['lat'],i])
        b.append([stations[i]['long'],i])
    a.sort()
    b.sort()
    minlatstation=a[0][1]
    maxlatstation=a[-1][1]
    minlongstation=b[0][1]
    maxlongstation=b[-1][1]
    c=[minlatstation,maxlatstation,minlongstation,maxlongstation]

    return c
def k_nearby_stations(stations, main_station, K):

    a=[]
    c=[]
    if main_station in stations:
        for i in stations:
            if main_station!=i:
                a.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i])
        a.sort()
        b=a[0:K]
        for i,j in b:
            c.append(j)
    return c
def average_temp(stations, names):
    s=0
    for i in names:
        if i in stations:
            s+=stations[i]['temp']
    return s/len(names)






# --------------------------------------------------
# 6330481621 (30) 303 (2021-03-29 00:09)

def approx_match(stations, name):
    a=name.replace(' ','')
    a1=a.upper()
    b=[]
    for key in stations:
        c=key.replace(' ','')
        if a1 in c.upper():
            b.append(key)
    return b
def top_k_min_temp_stations(stations, K):
    a=[[stations[i]['temp'],i] for i in stations]
    b=sorted(a)
    c=[]
    if len(b)>=K:
        for i in range(K):
            c.append(b[i][1])
    else:
        K=len(b)
        for i in range(K):
            c.append(b[i][1])
    return c
def top_k_max_temp_stations(stations, K):
    a=[[-stations[i]['temp'],i] for i in stations]
    a.sort()
    c=[]
    if len(a)>=K:
        for i in range(K):
            c.append(a[i][1])
    else:
        K=len(a)
        for i in range(K):
            c.append(a[i][1])
    return c
def peak_stations(stations):
    a=[[stations[i]['lat'],i] for i in stations]
    a.sort()
    b=[[stations[i]['long'],i] for i in stations]
    b.sort()
    return [a[0][1],a[-1][1],b[0][1],b[-1][1]]
def k_nearby_stations(stations, main_station, K):
    a=[[distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i] for i in stations]
    a.sort()
    a=a[1::]
    b=[]
    if len(a)>=K:
        for i in range(K):
            b.append(a[i][1])
    else:
        K=len(a)
        for i in range(K):
            b.append(a[i][1])
    return b
def average_temp(stations, names):
    s=0
    for i in range(len(names)):
        s+=stations[names[i]]['temp']
    return s/len(names)
# --------------------------------------------------
# 6330482221 (30) 304 (2021-03-29 18:49)

def approx_match(stations, name):
    name_cut = "" ;l = []
    for i in name.upper():
        if i.isalpha():
            name_cut += i
        elif i == " ":
            name_cut += ""
        else: name_cut += i
    for e in stations:
        try:
            a = "".join(e.upper().split())
            if name_cut in a:
                l.append(e)
        except:
            if name_cut in e.upper():
                l.append(e)
    return l
def top_k_min_temp_stations(stations, K):
    if K > len(stations): K = len(stations)
    l = [] ;l1 = []
    for i in stations:
        l.append([stations[i]["temp"],i])
    l.sort()
    for i in range(K):
        l1.append(l[i][1])
    return l1
def top_k_max_temp_stations(stations, K):
    if K > len(stations): K = len(stations)
    l = [] ;ans = []
    for i in stations:
        l.append([stations[i]["temp"],i])
    l.sort(reverse=True)
    for i in l:
        i[0] = -i[0]
    l.sort()
    for i in l:
        i[0] = -i[0]
    for i in l:
        ans.append(i[1])
    return (ans[0:K])
def peak_stations(stations):
    l = [] ;l1 = [] ;l2 =[0,0,0,0] ;ans = []
    for i in stations:
        l.append([stations[i]["lat"],i])
        l1.append([stations[i]["long"],i])
    l2[1] = max(l) ; l2[0] = min(l) ; l2[3] = max(l1) ; l2[2] = min(l1)
    for k in l2:
        ans.append(k[1])
    return ans
def k_nearby_stations(stations, main_station, K):
    l = [] ;d = [] ;ans = []
    for i in stations:
        if i == main_station.upper():
            l.append(stations[i])
    for i in stations:
        dis = distance(l[0]["lat"],l[0]["long"],stations[i]["lat"],stations[i]["long"])
        d.append([dis,i])
    d.sort()
    d = d[1:K+1]
    for i in d:
        ans.append(i[1])
    return ans
def average_temp(stations, names):
    av_temp = 0 ;st = 0
    for i in names:
        av_temp += stations[i]["temp"]
        st += 1
    return av_temp/st

# --------------------------------------------------
# 6330483921 (30) 305 (2021-03-29 21:46)

def approx_match(stations, name):
    a=name.upper()
    b=a.split()
    c=''.join(b)
    d=[]
    for k in stations :
        if c in k :
            d.append(k)
    return d
def top_k_min_temp_stations(stations, K):
    d=[]
    for i in stations :
        a=stations[i]['temp']
        d.append([a,i])
    d.sort()
    e=d[:K]
    f=[]
    for i in e :
        f.append(i[1])
    return f
def top_k_max_temp_stations(stations, K):
    d=[]
    for i in stations :
        a=stations[i]['temp']
        d.append([-a,i])
    d.sort()
    e=d[:K]
    f=[]
    for i in e :
        f.append(i[1])
    return f
def peak_stations(stations):
    lat=[]
    long=[]
    for i in stations :
        lat.append([stations[i]['lat'],i])
        long.append([stations[i]['long'],i])
    a=min(lat)[1]
    b=max(lat)[1]
    c=min(long)[1]
    d=max(long)[1]
    return [a,b,c,d]
def k_nearby_stations(stations, main_station, K):
    d=[]
    for i in stations :
        dis=distance(stations[i]['lat'],stations[i]['long'] \
                     ,stations[main_station]['lat'],stations[main_station]['long'])
        d.append([dis,i])
    d.sort()
    e=d[:K+1]
    f=[]
    for i in e :
        f.append(i[1])
    return f[1:]
def average_temp(stations, names):
    d=[]
    for i in stations :
        if i in names :
            d.append(stations[i]['temp'])
    return sum(d)/len(d)
# --------------------------------------------------
# 6330485121 (25.98) 306 (2021-03-29 18:54)

def approx_match(stations, name):
    st = []
    for e in stations:
        if (''.join(name.split())).lower() in (''.join(e.split())).lower(): st.append(e)
    return st
def top_k_min_temp_stations(stations, K):
    st = [] ; topmin = []
    for e in stations: st.append([stations[e]['temp'], e])
    st.sort()
    if K>len(stations): K = len(stations)
    for i in range(K): topmin.append(st[i][1])
    return topmin
def top_k_max_temp_stations(stations, K):
    st = [] ; topmax = []
    for e in stations: st.append([-(stations[e]['temp']), e])
    st.sort()
    if K>len(stations): K = len(stations)
    for i in range(K): topmax.append(st[i][1])
    return topmax
def peak_stations(stations):
    lat = [] ; long = [] ; peak = []
    for e in stations: lat.append(stations[e]['lat']) ; long.append(stations[e]['long'])
    mxlat = max(lat) ; mnlat = min(lat) ; mxlong = max(long) ; mnlong = min(long)
    for e in stations:
        if stations[e]['lat'] == mnlat: peak.append(e)
    for e in stations:
        if stations[e]['lat'] == mxlat: peak.append(e)
    for e in stations:
        if stations[e]['long'] == mnlong: peak.append(e)
    for e in stations:
        if stations[e]['long'] == mxlong: peak.append(e)
    return peak
def k_nearby_stations(stations, main_station, K):
    dist = []
    st = []
    for e in stations:
        dist.append([distance(stations[e]['lat'], stations[e]['long'], stations[main_station]['lat'], stations[main_station]['long']), e])
    dist.sort()
    if K>len(stations): K = len(stations)
    for i in range(K-1):
        st.append(dist[i+1][1])
    return st
def average_temp(stations, names):
    temp = []
    for e in stations:
        if e in names: temp.append(stations[e]['temp'])
    av = sum(temp)/len(names)
    return av
# --------------------------------------------------
# 6330486821 (30) 307 (2021-03-28 01:02)

def approx_match(stations, name):
    name = ''.join([c for c in name.upper() if c!=' '])
    return [k for k in stations if ''.join(k.split()).find(name)!=-1]
def top_k_min_temp_stations(stations, K):
    temp_sta = sorted([[stations[k]['temp'],k] for k in stations])
    return [k for t,k in temp_sta][:K]
def top_k_max_temp_stations(stations, K):
    temp_sta = sorted([[-stations[k]['temp'],k] for k in stations])
    return [k for t,k in temp_sta][:K]
def peak_stations(stations):
    lat_sta = sorted([[stations[k]['lat'],k] for k in stations])
    long_sta = sorted([[stations[k]['long'],k] for k in stations])
    return [lat_sta[0][1],lat_sta[-1][1],long_sta[0][1],long_sta[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat,long = stations[main_station]['lat'],stations[main_station]['long']
    d_sta = sorted([[distance(lat,long,stations[k]['lat'],stations[k]['long']), k] \
                    for k in stations if k!=main_station])
    return [k for d,k in d_sta][:K]
def average_temp(stations, names):
    return sum([stations[k]['temp'] for k in names])/len(names)

# --------------------------------------------------
# 6330487421 (30) 308 (2021-03-29 23:41)

def approx_match(stations, name):
    s = []
    nameEdit = ''
    for i in name:
        if i != ' ':
            nameEdit += i.upper()

    for j in stations:
        kEdit = ''
        for i in j:
            if i != ' ':
                kEdit += i.upper()
        if nameEdit in kEdit:
            s.append(j)

    return s
def top_k_min_temp_stations(stations, K):
    s = []
    for i in stations:
        if len(s) < K:
            s.append([stations[i]['temp'], i])
            s.sort()
        else:
            for m in range(len(s)):
                if [stations[i]['temp'], i] < s[m]:
                    s.insert(m, [stations[i]['temp'], i])
                    s.pop(-1)
                    break

    for p in range(len(s)):
        s[p] = s[p][1]

    return s
def top_k_max_temp_stations(stations, K):
    s = []
    for m in stations:
        if len(s) < K:
            s.append([-stations[m]['temp'], m])
            s.sort()
        else:
            for i in range(len(s)):
                if [-stations[m]['temp'], m] < s[i]:
                    s.insert(i, [-stations[m]['temp'], m])
                    s.pop(-1)
                    break

    for p in range(len(s)):
        s[p] = s[p][1]

    return s
def peak_stations(stations):
    r = []
    for k in stations:
        if len(r) == 0:
            r = [[stations[k]['lat'], k], [stations[k]['lat'], k], [stations[k]['long'], k], [stations[k]['long'], k]]
        else:
            if [stations[k]['lat'], k] < r[0]:
                r[0] = [stations[k]['lat'], k]
            if [stations[k]['lat'], k] > r[1]:
                r[1] = [stations[k]['lat'], k]
            if [stations[k]['long'], k] < r[2]:
                r[2] = [stations[k]['long'], k]
            if [stations[k]['long'], k] > r[3]:
                r[3] = [stations[k]['long'], k]

    for i in range(len(r)):
        r[i] = r[i][1]

    return r
def k_nearby_stations(stations, main_station, K):
    r = []
    for k in stations:
        if k != main_station:
            if len(r) < K:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                r.append([d, k])
                r.sort()
            else:
                d = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
                for i in range(len(r)):
                    if [d, k] < r[i]:
                        r.insert(i, [d, k])
                        r.pop(-1)
                        break

    for i in range(len(r)):
        r[i] = r[i][1]

    return r
def average_temp(stations, names):
    s=0
    for i in names:
        s=s+stations[i]['temp']

    avg=s/len(names)

    return avg


# --------------------------------------------------
# 6330488021 (30) 309 (2021-03-29 21:28)

def approx_match(stations, name):
    s=[]
    name2=name.upper()
    n=''

    for c in name2:
        if c!=' ':
             n+=c


    for k in stations:

        station = ''
        name_s=k.upper()


        for c in name_s:
            if c!=' ':
                 station+=c


        if n in station :
            s.append(k)

    return s
def top_k_min_temp_stations(stations, K):


    min_temp=[]
    min_stations =[]
    for k in stations:
        min_temp.append([stations[k]['temp'],k])
    min_temp.sort()
    min_temp = min_temp[:K]
    for a,b in min_temp:
        min_stations.append(b)



    return min_stations
def top_k_max_temp_stations(stations, K):
    max_temp=[]
    max_stations=[]
    for k in stations:
        max_temp.append([-stations[k]['temp'],k])
    max_temp.sort()
    max_temp = max_temp[:K]
    for a,b in max_temp:
        max_stations.append(b)

    return max_stations
def peak_stations(stations):

    lat =[]
    long =[]
    for k in stations:
        lat.append(stations[k]['lat'])
        long.append(stations[k]['long'])
    lat.sort()
    long.sort()
    min_lat = lat[0]
    max_lat = lat[-1]

    min_long = long[0]
    max_long = long[-1]

    for t in stations:
        if stations[t]['lat']==min_lat:
            a=t
        if stations[t]['lat']==max_lat:
            b=t
        if stations[t]['long'] == min_long:
            c=t
        if stations[t]['long'] == max_long:
            d=t

    p_stations =[a,b,c,d]

    return p_stations
def k_nearby_stations(stations, main_station, K):

    d=[]
    if main_station in stations:
            lat2=stations[main_station]['lat']
            long2=stations[main_station]['long']
    for k in stations:
        lat1=stations[k]['lat']
        long1=stations[k]['long']

        dis = distance(lat1, long1, lat2, long2)
        d.append([dis,k])

    d.sort()
    close_dis=d[1:K+1]
    close_stations=[]
    for a,b in close_dis:
        close_stations.append(b)

    return close_stations
def average_temp(stations, names):
    sum=0

    for e in names:

        sum+=stations[e]['temp']
    average = sum/len(names)

    return average


# --------------------------------------------------
# 6330489721 (30) 310 (2021-03-29 17:36)

def approx_match(stations, name):
    x = ''
    y = []
    for i in range(len(name)):
        if 'A' <= name[i] <= 'Z' or \
           'a' <= name[i] <= 'z':
            x += name[i]
    x = x.upper()

    for e in stations:
        a = e.split()
        a = ''.join(a)
        a = a.upper()
        if x in a:
            y.append(e)
    return y
def top_k_min_temp_stations(stations, K):
    z = []
    w = []
    for e in stations:
        z.append([stations[e]['temp'],e])
    z.sort()
    for i in range(K):
        w.append(z[i][1])
    return w
def top_k_max_temp_stations(stations, K):
    z = []
    w = []
    for e in stations:
        z.append([-1*stations[e]['temp'],e])
    z.sort()
    for i in range(K):
        w.append(z[i][1])
    return w
def peak_stations(stations):
    min_la = -100
    max_la = 100
    min_lo = -200
    max_lo = 200
    min_la_station = ''
    min_lo_station = ''
    max_la_station = ''
    max_lo_station = ''
    for i in stations.items():
        longtitude = i[1]['long']
        latitude = i[1]['lat']
        name= i[0]

        if latitude > min_la:
            min_la = latitude
            min_la_station = name
        if latitude < max_la:
            max_la = latitude
            max_la_station = name

        if longtitude > min_lo:
            min_lo = longtitude
            min_lo_station = name
        if longtitude < max_lo:
            max_lo = longtitude
            max_lo_station = name
    laloname = [max_la_station,min_la_station,max_lo_station,min_lo_station]

    return laloname
def k_nearby_stations(stations, main_station, K):
    f = []
    g = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']

    for i in stations:
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        d = distance(lat1, long1, lat2, long2)
        f.append([d,i])
    f.sort()
    for i in range(K):
        g.append(f[i+1][1])
    return g
def average_temp(stations, names):
    c = 0
    for i in names:
        c += stations[i]['temp']

    x = c/len(names)

    return x

# --------------------------------------------------
# 6330491921 (30) 311 (2021-03-29 19:48)

def approx_match(stations, name):
    name = name.lower().replace(" ","")
    resultzz = [x for x in stations if name in x.lower().replace(" ","")]
    return resultzz

#---------------------------------------------------
def top_k_min_temp_stations(stations, K):
    s_data = sorted(stations,key = lambda x: stations[x]["temp"])
    return s_data[0:K]

#---------------------------------------------------
def top_k_max_temp_stations(stations, K):
    s_data = sorted(stations,key = lambda x: stations[x]["temp"],reverse = True)
    return s_data[0:K]

#---------------------------------------------------
def peak_stations(stations):
    maxi_lati = max(stations, key = lambda k:float(stations[k]["lat"]))
    mini_lati = min(stations, key = lambda k:float(stations[k]["lat"]))
    maxi_longi = max(stations, key = lambda k:float(stations[k]["long"]))
    mini_longi = min(stations, key = lambda k:float(stations[k]["long"]))
    return [mini_lati,maxi_lati,mini_longi,maxi_longi]

#---------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    near = sorted(stations, key = lambda d: distance(stations[d]['lat'],stations[d]['long']\
                                                     ,stations[main_station]['lat'],stations[main_station]['long']))
    return near[1:K+1]

#---------------------------------------------------
def average_temp(stations, names):
    total = 0
    for e in names:
        total += stations[e]['temp']

    average = total/len(names)
    return average

# --------------------------------------------------
# 6330492521 (28.74) 312 (2021-03-29 20:37)

def approx_match(stations, name):
    name = name.upper().replace(" ","")
    x=''
    y=[]
    for city in range(len(name)):
        x+=name[city]
    for city in stations:
        if x in city.upper().replace(" ",""):
            y.append(city)
    return y
def top_k_min_temp_stations(stations, K):
    t = []
    for city in stations:
        t.append([stations[city]['temp'],city])
    tt = [t[1] for t in sorted(t,reverse=False)]
    return tt[:K]
def top_k_max_temp_stations(stations, K):
    t = []
    for city in stations:
        t.append([stations[city]['temp'],city])
    tt = [t[1] for t in sorted(t,reverse=True)]
    return tt[:K]
def peak_stations(stations):
    la = []
    long = []
    for city in stations:
        la.append([stations[city]['lat'],city])
        long.append([stations[city]['long'],city])
    la2 = [la[1] for la in sorted(la)]
    long2 = [long[1] for long in sorted(long)]
    return [la2[0],la2[-1],long2[0],long2[-1]]
def k_nearby_stations(stations, main_station, K):
    name = main_station.upper()
    x=''
    y=[]
    for city in range(len(name)):
        x+=name[city]
    dis = []
    for city in stations:
        dis.append([distance(stations[x]['lat'],stations[x]['long'], stations[city]['lat'],stations[city]['long']),city])
    dis2 = [dis[1] for dis in sorted(dis)]
    return dis2[1:K+1]
def average_temp(stations, names):
    avg = []
    for city in names:
        avg.append(stations[city]['temp'])
    return sum(avg)/len(names)

# --------------------------------------------------
# 6330494821 (27.72) 313 (2021-03-25 16:06)

def approx_match(stations, name):
    n=''
    names=[]
    for c in name:
        if 'A'<=c<='z':
            n+=c.upper()
    for c in stations:
        if n in c:
            names.append(c)
    return names
def top_k_min_temp_stations(stations, K):
    a=[]
    for n in stations:
        a.append([stations[n]['temp'],n])
    a.sort()
    b=[]
    for i in range(K):
        b.append(a[i][1])
    return b
def top_k_max_temp_stations(stations, K):
    a=[]
    for n in stations:
        a.append([stations[n]['temp'],n])
    a.sort(reverse=True)
    b=[a[0][1]]
    c=[]
    for i in range(1,len(a)):
        if a[i][0]==a[i-1][0]:
            b.append(a[i][1])
        else:
            b.sort()
            for x in b:
                c.append(x)
            b=[]
    b.sort()
    for x in b:
        c.append(x)
    d=[]
    for i in range(K):
        d.append(a[i][1])
    return d
def peak_stations(stations):
    a=[]
    b=[]
    for n in stations:
        a.append([stations[n]['lat'],n])
    a.sort()
    for n in stations:
        b.append([stations[n]['long'],n])
    b.sort()
    c=[]
    c.append(a[0][1])
    c.append(a[-1][1])
    c.append(b[0][1])
    c.append(b[-1][1])
    return c
def k_nearby_stations(stations, main_station, K):
    a=[]
    for n in stations:
        a.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[n]['lat'],stations[n]['long']),n])
    b=[]
    for i in range(K):
        b.append(a[i][1])
    return b
def average_temp(stations, names):
    sum=0
    for x in names:
        sum+=stations[x]['temp']
    average=sum/len(names)
    return average
# --------------------------------------------------
# 6330495421 (28.74) 314 (2021-03-29 15:56)

def approx_match(stations, name):
    name=name.upper().split()
    s="".join(name)
    list_stations=[]
    for key in stations:
        a="".join(key).upper()
        if s in a:
            list_stations.append(key)
    return list_stations
def top_k_min_temp_stations(stations, K):
    temp=[]
    for key in stations:
        t=stations[key]["temp"]
        temp.append([t,key])
    temp.sort()
    if K > len(temp):
        return temp()
    min_temp=temp[:K]
    min_name=[]
    for i in range (len(min_temp)):
        min_name.append(min_temp[i][1])
    return min_name
def top_k_max_temp_stations(stations, K):
    temp=[]
    for key in stations:
        t=stations[key]["temp"]
        temp.append([t,key])
    temp.sort(reverse=True)
    if K > len(temp):
        return temp
    min_temp=temp[:K]
    min_name=[]
    for i in range (len(min_temp)):
        min_name.append(min_temp[i][1])
    return min_name
def peak_stations(stations):
    list_latitude=[]
    list_longitude=[]
    name_stations=[]
    for key in stations:
        latitude=stations[key]["lat"]
        list_latitude.append([latitude,key])
    for key in stations:
        longitude=stations[key]["long"]
        list_longitude.append([longitude,key])
    list_latitude.sort()
    min_lat=list_latitude[0][1]
    name_stations.append(min_lat)
    list_latitude.sort(reverse=True)
    max_lat=list_latitude[0][1]
    name_stations.append(max_lat)
    list_longitude.sort()
    min_long=list_longitude[0][1]
    name_stations.append(min_long)
    list_longitude.sort(reverse=True)
    max_long=list_longitude[0][1]
    name_stations.append(max_long)
    return name_stations
def k_nearby_stations(stations, main_station, K):
    list_distance=[]
    lat1=stations[main_station]["lat"]
    long1=stations[main_station]["long"]
    for key in stations:
        lat2=stations[key]["lat"]
        long2=stations[key]["long"]
        a=distance(lat1,long1,lat2,long2)
        if a!=0:
            list_distance.append([a,key])
    list_distance.sort()
    name=[]
    if K>len(list_distance):
        return list_distance
    list_distance=list_distance[:K]

    for i in range (len(list_distance)):
        name.append(list_distance[i][1])
    return name
def average_temp(stations, names):
    c=0
    n=len(names)
    for e in names:
        c+=float(stations[e]["temp"])
    avg_temp=c/n
    return avg_temp




# --------------------------------------------------
# 6330496021 (30) 315 (2021-03-29 22:24)

def approx_match(stations, name):
    x = []
    name = name.split()
    name = ''.join(name)
    name = name.upper()
    for key in stations:
        a = key
        a = a.split()
        a = ''.join(a)
        a = a.upper()
        if name in a:
            x = x+[key]
    return x
def top_k_min_temp_stations(stations, K):
    a = []
    for key in stations:
        a.append([stations[key]['temp'],key])
    a = sorted(a)
    x = [b for g,b in [[a[i][0],a[i][1]] for i in range(len(a))]]
    return x[:K]
def top_k_max_temp_stations(stations, K):
    a = []
    for key in stations:
        a.append([-stations[key]['temp'],key])
    a = sorted(a)
    x = [b for g,b in [[a[i][0],a[i][1]] for i in range(len(a))]]
    return x[:K]
def peak_stations(stations):
    latmin = []
    for key in stations:
        latmin.append([stations[key]['lat'],key])
    latmin = sorted(latmin)
    latmin_ = [b for g,b in [[latmin[i][0],latmin[i][1]] for i in range(len(latmin))]]
    latmax = []
    for key in stations:
        latmax.append([-stations[key]['lat'],key])
    latmax = sorted(latmax)
    latmax_ = [b for g,b in [[latmax[i][0],latmax[i][1]] for i in range(len(latmax))]]
    longmin = []
    for key in stations:
        longmin.append([stations[key]['long'],key])
    longmin = sorted(longmin)
    longmin_ = [b for g,b in [[longmin[i][0],longmin[i][1]] for i in range(len(longmin))]]
    longmax = []
    for key in stations:
        longmax.append([-stations[key]['long'],key])
    longmax = sorted(longmax)
    longmax_ = [b for g,b in [[longmax[i][0],longmax[i][1]] for i in range(len(longmax))]]
    peak = [latmin_[0],latmax_[0],longmin_[0],longmax_[0]]
    return peak
def k_nearby_stations(stations, main_station, K):
    a = []
    for key in stations:
        a.append([distance(stations[key]['lat'] ,stations[key]['long'],stations[main_station]['lat'],stations[main_station]['long']),key])
    a = sorted(a)
    x = [b for g,b in [[a[i][0],a[i][1]] for i in range(len(a))]]
    return x[1:K+1]
def average_temp(stations, names):
    a = []
    for x in names:
        a.append(stations[x]['temp'])
    k = sum(a)/len(a)
    return k



# --------------------------------------------------
# 6330497721 (30) 316 (2021-03-25 16:41)

def approx_match(stations, name):
    name=adjust_text(name)
    names=[]
    for each_station in stations:
        if name in each_station:
            names.append(each_station)
    return names
def top_k_min_temp_stations(stations, K):
    info=[[temp,station] for [station,temp] in stations_temp(stations)]
    top_min_temp_k=sorted(info)[:K]
    top_min_temp_k=[station for [temp,station] in top_min_temp_k]
    return top_min_temp_k
def top_k_max_temp_stations(stations, K):
    info=[[-temp,station] for [station,temp] in stations_temp(stations)]
    top_max_temp_k=sorted(info)[:K]
    top_max_temp_k=[station for [temp,station] in top_max_temp_k]
    return top_max_temp_k
def peak_stations(stations):
    lat=[[lat,station] for [station,lat] in stations_lat(stations)]
    min_lat=sorted(lat)[0]
    max_lat=sorted(lat,reverse=True)[0]
    long=[[long,station] for [station,long] in stations_long(stations)]
    min_long=sorted(long)[0]
    max_long=sorted(long,reverse=True)[0]
    return [min_lat[1],max_lat[1],min_long[1],max_long[1]]
def k_nearby_stations(stations, main_station, K):
    info_main_station=[main_station]
    info_main_station.append(stations[main_station]['lat'])
    info_main_station.append(stations[main_station]['long'])
    info_staions=stations_lat_long(stations)
    for i in range(len(info_staions)):
        dis=distance(info_main_station[1], info_main_station[2], info_staions[i][1], info_staions[i][2])
        info_staions[i].append(dis)
    info_staions=sorted([[dis,station,lat,long] for [station,lat,long,dis] in info_staions])[1:K+1]
    nearby_stations=[]
    for i in range(len(info_staions)):
        nearby_stations.append(info_staions[i][1])
    return nearby_stations
def average_temp(stations, names):
    info=[]
    for name in names:
        temp=stations[name]['temp']
        info.append(temp)
    return sum(info)/len(info)

# --------------------------------------------------
def adjust_text(name):
    name=name.upper()
    new_name=''
    for ch in name:
        if ch.isalpha():
            new_name+=ch
    return new_name
def stations_temp(stations):
    stations_temp=[]
    for each_key in stations:
        temp=stations[each_key]['temp']
        stations_temp.append([each_key,temp])
    return stations_temp
def stations_lat(stations):
    stations_lat=[]
    for each_key in stations:
        lat=stations[each_key]['lat']
        stations_lat.append([each_key,lat])
    return stations_lat
def stations_long(stations):
    stations_long=[]
    for each_key in stations:
        long=stations[each_key]['long']
        stations_long.append([each_key,long])
    return stations_long
def stations_lat_long(stations):
    stations_lat_long=[]
    for each_key in stations:
        lat=stations[each_key]['lat']
        long=stations[each_key]['long']
        stations_lat_long.append([each_key,lat,long])
    return stations_lat_long
#
# 6330498321 (30) 317 (2021-03-29 19:53)

def approx_match(stations, name):
    name=name.lower()
    name2=''
    alpha='abcdefghijklmnopqrstuvwxyz'
    for i in name:
        if i.lower() in alpha:
            name2+=i
    ma_list=[]
    for i in stations:
        t=''
        for k in i:
            if k.lower() in alpha:
                t+=k
        if name2 in t.lower():
            ma_list.append(i)
    return ma_list
def top_k_min_temp_stations(stations, K):
    temp_station=[]
    for i in stations:
        temp_station.append([stations[i]['temp'],i])
    temp_station.sort()
    if K>len(temp_station):
        return [i[1] for i in temp_station]
    else:
        return [i[1] for i in temp_station[0:K]]
def top_k_max_temp_stations(stations, K):
    temp_station=[]
    for i in stations:
        temp_station.append([stations[i]['temp'],i])
    temp_station.sort()
    temp_station=temp_station[::-1]
    for i in range(len(temp_station)-1):
        for j in range(len(temp_station)-1):
            if temp_station[j][1]>temp_station[j+1][1] and temp_station[j][0]==temp_station[j+1][0]:
                temp_station[j],temp_station[j+1]=temp_station[j+1],temp_station[j]
    if K>len(temp_station):
        return [i[1] for i in temp_station]
    else:
        return [i[1] for i in temp_station[0:K]]
def peak_stations(stations):
    station_lat=[]
    station_long=[]
    for i in stations:
        station_lat.append([stations[i]['lat'],i])
        station_long.append([stations[i]['long'],i])
    station_lat.sort()
    station_long.sort()
    ma=[station_lat[0][1],station_lat[-1][1],station_long[0][1],station_long[-1][1]]
    return ma
def k_nearby_stations(stations, main_station, K):
    distancex=[]
    e=main_station
    for i in stations:
        if i!=main_station:
            distancex.append([distance(stations[i]['lat'],stations[i]['long'],stations[e]['lat'],stations[e]['long']),i])
    distancex.sort()
    for i in range(len(distancex)-1):
        for j in range(len(distancex)-1):
            if distancex[j][1]>distancex[j+1][1] and distancex[j][0]==distancex[j+1][0]:
                distancex[j],distancex[j+1]=distancex[j+1],distancex[j]
    if K>len(distancex):
        return [i[1] for i in distancex]
    else:
        return [i[1] for i in distancex[0:K]]
def average_temp(stations, names):
    s=0
    m=0
    for i in names:
        s+=stations[i]['temp']
        m+=1
    mean=s/m
    return mean
# --------------------------------------------------
# 6330499021 (30) 318 (2021-03-29 22:02)

def approx_match(stations, name):
    name_1 = name.upper().split()
    foo = ''.join(name_1)

    ans = []
    for word in stations.keys():
        words = word.replace(' ', '')
        if foo in word:
            ans.append(word)
        elif foo == words:
            ans.append(word)
    return ans
def top_k_min_temp_stations(stations, K):
    temp = []
    for station in stations.keys():
        temp.append((station, stations[station]['temp']))

    station_temp_sorted = sorted(sorted(temp, key=lambda x: x[0]), key=lambda x: x[1])

    ans= [station[0] for station in station_temp_sorted][:K]

    return ans
def top_k_max_temp_stations(stations, K):
    temp = []
    for station in stations.keys():
        temp.append((station, stations[station]['temp']))

    station_temp_sorted = sorted(sorted(temp, key=lambda x: x[0]), key=lambda x: x[1],reverse=True)

    ans= [station[0] for station in station_temp_sorted][:K]

    return ans
def peak_stations(stations):
    a_station_name = []
    for key in stations:
        a_station_name.append(key)

    lat = []
    for station in a_station_name:
        lat.append(stations[station]['lat'])

    long = []
    for station in a_station_name:
        long.append(stations[station]['long'])

    station_lat = list(zip(a_station_name, lat))
    station_lat_sorted_1 = sorted(sorted(station_lat, key=lambda x: x[0]), key=lambda x: x[1])
    station_lat_sorted_2 = sorted(sorted(station_lat, key=lambda x: x[0]), key=lambda x: x[1], reverse=True)

    station_lat_min = station_lat_sorted_1[0][0]
    station_lat_max = station_lat_sorted_2[0][0]

    station_long = list(zip(a_station_name, long))
    station_long_sorted_1 = sorted(sorted(station_long, key=lambda x: x[0]), key=lambda x: x[1])
    station_long_sorted_2 = sorted(sorted(station_long, key=lambda x: x[0]), key=lambda x: x[1], reverse=True)

    station_long_min = station_long_sorted_1[0][0]
    station_long_max = station_long_sorted_2[0][0]

    ans = []
    ans.append(station_lat_min)
    ans.append(station_lat_max)
    ans.append(station_long_min)
    ans.append(station_long_max)

    return ans
def k_nearby_stations(stations, main_station, K):

    lat = []
    for station in stations:
        lat.append(stations[station]['lat'])
    long = []
    for station in stations:
        long.append(stations[station]['long'])

    lat_x = stations[main_station]['lat']
    long_x = stations[main_station]['long']

    x = []
    for i in range(len(stations)):
        x.append(distance(lat[i],long[i], lat_x,long_x))
    stations_dis = list(zip(stations, x))
    stations_dis_sorted = sorted(sorted(stations_dis, key=lambda x: x[0]), key=lambda x: x[1])
    ans = []
    for station in stations_dis_sorted:
        if station[0] == main_station:
            pass
        else:
            ans.append(station)

    keshi=[station[0] for station in ans][:K]

    return keshi
def average_temp(stations, names):

    temp=[]
    for station in names:
        temp.append(stations[station]['temp'])
    ans=sum(temp)/len(temp)
    return ans


# --------------------------------------------------
# 6330500921 (30) 319 (2021-03-29 03:11)

def approx_match(stations, name):
    upppp=name.upper()
    a=list(upppp)
    s=[c for c in a if c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']

    b=''.join(s)

    anrake=[]

    for f in stations:
        upp=f.upper()
        m=list(upp)
        h=[k for k in m if k in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
        c=''.join(h)

        if b in c:
            anrake.append(f)
    return anrake
def top_k_min_temp_stations(stations, K):
    a=sorted([[stations[i]['temp'],i] for i in stations])
    if len(a)>= K:
        ansong=[a[f][1] for f in range(K)]
    else:
        ansong=[a[f][1] for f in range(a)]
    return ansong
def top_k_max_temp_stations(stations, K):
    a=sorted([[(-1)*stations[i]['temp'],i] for i in stations])
    if len(a)>= K:
        ansarm=[a[f][1] for f in range(K)]
    else:
        ansarm=[a[f][1] for f in range(a)]
    return ansarm
def peak_stations(stations):
    a=sorted([[stations[i]['lat'],i] for i in stations])
    b=sorted([[stations[i]['long'],i] for i in stations])
    ansee=[]
    ansee=ansee+[a[0][1]]
    ansee=ansee+[a[-1][1]]
    ansee=ansee+[b[0][1]]
    ansee=ansee+[b[-1][1]]
    return ansee
def k_nearby_stations(stations, main_station, K):

    a=sorted([[distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i] for i in stations if distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long'])>0])
    if len(a)>= K:
        anhaa=[a[f][1] for f in range(K)]
    else:
        anhaa=[a[f][1] for f in range(a)]
    return anhaa
def average_temp(stations, names):
    a=0
    for i in names :
        b=stations[i]['temp']
        a=a+b
    anhok = a/len(names)
    return anhok



# --------------------------------------------------
# 6330501521 (30) 320 (2021-03-28 15:25)

def approx_match(stations, name):
    m=name.upper()
    n=''
    a=[]
    for i in m:
        if i!= ' ':
            n+=i
    for e in stations:
        ee=e.upper()
        E=''
        for ch in ee:
            if ch.isalpha():
                E+=ch
        if n in E:
            a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    t=sorted([[stations[e]['temp'],e] for e in stations])
    T=t[:K:]
    mn=[T[i][1] for i in range(len(T))]
    return mn
def top_k_max_temp_stations(stations, K):
    t=sorted([[-stations[e]['temp'],e] for e in stations])
    T=t[:K:]
    mx=[T[i][1] for i in range(len(T))]
    return mx
def peak_stations(stations):
    la=[[stations[e]['lat'],e] for e in stations]
    laa=[[-stations[e]['lat'],e] for e in stations]
    La_min=min(la)
    La_max=min(laa)
    lo=[[stations[e]['long'],e] for e in stations]
    loo=[[-stations[e]['long'],e] for e in stations]
    Lo_min=min(lo)
    Lo_max=min(loo)
    pp=[La_min[1],La_max[1],Lo_min[1],Lo_max[1]]
    return pp
def k_nearby_stations(stations, main_station, K):
    d=[]
    for i in stations:
        d.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i])
    d.sort()
    n=d[1:K+1:]
    N=[n[i][1] for i in range(len(n))]
    return N
def average_temp(stations, names):
    av=0
    for i in names:
        av+=stations[i]['temp']
        mean=av/len(names)
    return mean

# --------------------------------------------------
# 6330502121 (30) 321 (2021-03-29 20:46)

def approx_match(stations, name):
    same=[]
    samenum=[]
    ant=[]
    inf=[]
    name=name.split()
    name=''.join(name)
    name=name.upper()
    for nam,info in stations.items():
        inf.append(nam)
        man=nam.split()
        man=''.join(man)
        ant.append(man)
    for i in ant:
        if name in i:
            samenum.append(ant.index(i))
    for i in samenum:
        same.append(inf[i])
    return same
def top_k_min_temp_stations(stations, K):
    all_temp=[]
    top_k=[]
    for nam, info in stations.items():
        all_temp.append([info['temp'],nam])
    all_temp.sort()
    for i in range(min(K,len(all_temp))):
        top_k.append(all_temp[i][1])
    return top_k
def top_k_max_temp_stations(stations, K):
    all_temp=[]
    top_k=[]
    for nam, info in stations.items():
        all_temp.append([-1*float(info['temp']),nam])
    all_temp.sort()
    for i in range(min(K,len(all_temp))):
        top_k.append(all_temp[i][1])
    return top_k
def peak_stations(stations):
    all_lat=[]
    all_long=[]
    peak=[]
    for nam, info in stations.items():
        all_lat.append([float(info['lat']),nam])
    all_lat.sort()
    peak.append(all_lat[0][1])
    for nam, info in stations.items():
        all_lat.append([-1*float(info['lat']),nam])
    all_lat.sort()
    peak.append(all_lat[0][1])
    for nam, info in stations.items():
        all_long.append([float(info['long']),nam])
    all_long.sort()
    peak.append(all_long[0][1])
    for nam, info in stations.items():
        all_long.append([-1*float(info['long']),nam])
    all_long.sort()
    peak.append(all_long[0][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    sth=[]
    peak=[]
    lat1=stations[main_station]['lat']
    long1=stations[main_station]['long']
    for nam,info in stations.items():
        lat2=stations[nam]['lat']
        long2=stations[nam]['long']
        dis=distance(lat1, long1, lat2, long2)
        sth.append([dis,nam])
    sth.sort()
    for i in range(min(K,len(sth))):
        peak.append(sth[i+1][1])
    return peak
def average_temp(stations, names):
    avg=0
    for i in names:
        avg+=float(stations[i]['temp'])
    n=len(names)
    avg=avg/n
    return avg


# --------------------------------------------------
# 6330503821 (28.74) 322 (2021-03-28 01:29)

def approx_match(stations, name):
    name = name.replace(" ", "").upper()
    result = []
    for station_name in stations:
        if name in station_name.replace(" ", "").upper():
            result.append(station_name)
    return result
def top_k_min_temp_stations(stations, K):
    stations_sorted_by_temperature = sorted(
        stations, key=lambda station_name: (stations[station_name]['temp'], station_name))
    print(stations_sorted_by_temperature[:K])
    return stations_sorted_by_temperature[:K]
def top_k_max_temp_stations(stations, K):
    stations_sorted_by_temperature = sorted(
        stations, key=lambda station_name: (stations[station_name]['temp'], station_name), reverse=True)
    print(stations_sorted_by_temperature[:K])
    return stations_sorted_by_temperature[:K]
def peak_stations(stations):
    sorted_lat = sorted(stations, key=lambda station_name: (
        stations[station_name]['lat'], station_name))
    sorted_long = sorted(stations, key=lambda station_name: (
        stations[station_name]['long'], station_name))
    return [sorted_lat[0], sorted_lat[-1], sorted_long[0], sorted_long[-1]]
def k_nearby_stations(stations, main_station, K):
    current = stations[main_station]
    all_dist = []
    for station_name in stations:
        if station_name == main_station:
            continue
        station = stations[station_name]
        dist = distance(current['lat'], current['long'],
                        station['lat'], station['long'])
        all_dist.append([dist, station_name])
    all_dist = sorted(all_dist, key=lambda pair: (pair[0], pair[1]))
    result = [pair[1] for pair in all_dist]

    return result[:K]
def average_temp(stations, names):
    result = 0
    count = 0
    for name in names:
        if name in stations:
            count += 1
            result += stations[name]['temp']
    return result/count



# --------------------------------------------------
# 6330504421 (30) 323 (2021-03-28 23:51)

def approx_match(stations, name):
    a = []
    b = ''
    c = ''
    name = name.upper()
    for i in name:
        if i != ' ':
            b += i
    for key in stations:
        for e in key:
            if e != ' ':
                c += e
        if b in c:
            a += [key]
        c = ''
    return a
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    for key in stations:
        a += [[stations[key]['temp'],key]]
    a = sorted(a)
    for i in range(K):
        b += [a[i][1]]
        if i == len(a)-1:
            break
    return b
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    for key in stations:
        a += [[stations[key]['temp'],key]]
    a = sorted(a, key=lambda x: x[1])
    a = sorted(a, key=lambda x: x[0],reverse=True)
    for i in range(K):
        b += [a[i][1]]
        if i == len(a)-1:
            break
    return b
def peak_stations(stations):
    a = []
    b = []
    c = []
    for key in stations:
        a += [[stations[key]['lat'],key]]
    a = sorted(a)
    for key in stations:
        b += [[stations[key]['long'],key]]
    b = sorted(b)
    c += [a[0][1],a[-1][1],b[0][1],b[-1][1]]
    return c
def k_nearby_stations(stations, main_station, K):
    a = stations[main_station]['lat']
    b = stations[main_station]['long']
    c = []
    x = []
    for key in stations:
        if key != main_station:
            d = stations[key]['lat']
            e = stations[key]['long']
            f = distance(a, b, d, e)
            c += [[f,key]]
    c = sorted(c)
    for i in range(K):
        x += [c[i][1]]
        if i == len(c)-1:
            break
    return x
def average_temp(stations, names):
    a = 0
    for i in names:
        a += stations[i]['temp']
    b = a/len(names)
    return b
# --------------------------------------------------
# 6330505021 (28.74) 324 (2021-03-29 10:24)

def approx_match(stations, name):
    c = name.upper()
    n = c.split()
    h = "".join(n)
    x = []
    for key in stations:
        key1 = key.upper()
        key2 = key1.split()
        key3 = ''.join(key2)
        if h in key3:
            x.append(key)
    return x
def top_k_min_temp_stations(stations, K):
    y = []
    x = []
    for e in stations:
        shabu = stations[e]['temp']
        comp = [shabu,e]
        y.append(comp)
    y.sort()
    for e in y :
        c = e[1]
        x.append(c)
    b = x[0:K:1]
    return b
def top_k_max_temp_stations(stations, K):
    y = []
    x = []
    for e in stations:
        shabu = stations[e]['temp']
        comp = [shabu,e]
        y.append(comp)
    y.sort(reverse=True)
    for e in y :
        c = e[1]
        x.append(c)
    b = x[0:K:1]
    return b
def peak_stations(stations):
    y = []
    x= []
    c= []
    b=[]
    nic=[]
    for e in stations:
        v=stations[e]['lat']
        h =[v,e]
        y.append(h)
    y.sort(reverse=True)
    for e in y:
        g=e[1]
        x.append(g)
    f =x[0]
    k =x[-1]
    c.append(k)
    c.append(f)

    for e in stations:
        n =stations[e]['long']
        ni =[n,e]
        b.append(ni)
    b.sort(reverse=True)
    for e in b:
        pi=e[1]
        nic.append(pi)
    fu =nic[0]
    nice =nic[-1]
    c.append(nice)
    c.append(fu)
    return c
def k_nearby_stations(stations, main_station, K):
    x = []
    y = []
    for i in stations:
        t = distance(float(stations[main_station]['lat']), float(stations[main_station]['long']),
                     float(stations[i]['lat']), float(stations[i]['long']))

        n = [t, i]
        x.append(n)
    x.sort()
    for i in x:
        c = i[1]
        y.append(c)
    p = y[1:K+1:1]
    return p
def average_temp(stations, names):
    n = 0
    for k in names:
        c = stations[k]['temp']
        c = float(c)
        n += c
    nice = n/(len(names))
    return nice




# --------------------------------------------------
# 6330507321 (30) 325 (2021-03-26 21:53)

def approx_match(stations, name):

    name=name.upper()
    rename=''
    for e in name:
        if 'A' <= e <= 'Z':
            rename += e
        else:
            pass
    stt=[]
    for i in stations:
        if rename in i:
            stt.append(i)
        else:
            pass

    return stt
def top_k_min_temp_stations(stations, K):
    tem=[]
    for e in stations:
        tem.append([stations[e]['temp'],e])
    tem.sort()
    min_k=[]
    for e in tem:
        min_k.append(e[1])
    min_k=min_k[0:K]
    return min_k
def top_k_max_temp_stations(stations, K):
    tem=[]
    for e in stations:
        tem.append([-float(stations[e]['temp']),e])
    tem.sort()
    max_k=[]
    for e in tem:
        max_k.append(e[1])
    max_k=max_k[0:K]
    return max_k
def peak_stations(stations):
    lat=[]
    for e in stations:
        lat.append([stations[e]['lat'],e])
    lat.sort()
    nlat=[]
    for e in lat:
        nlat.append(e[1])
    ans=[]
    ans.append(nlat[0])
    ans.append(nlat[-1])

    long=[]
    for e in stations:
        long.append([stations[e]['long'],e])
    long.sort()
    nlong=[]
    for e in long:
        nlong.append(e[1])
    ans.append(nlong[0])
    ans.append(nlong[-1])
    return ans
def k_nearby_stations(stations, main_station, K):
    main_station=main_station.upper()
    near=[]
    for e in stations:
        dis=distance(stations[main_station]['lat'],stations[main_station]['long'],stations[e]['lat'],stations[e]['long'])
        near.append([dis,e])
    near.sort()
    nest=[]
    for e in near:
        nest.append(e[1])
    nest=nest[1:K+1]
    return nest
def average_temp(stations, names):
    totaltemp=0
    for e in names:
        totaltemp+=stations[e]['temp']
    avtemp= totaltemp/len(names)
    return avtemp



# --------------------------------------------------
# 6330508021 (30) 326 (2021-03-29 11:58)

def approx_match(stations, name):
    name2 = ''
    for i in name:
        if i.isalnum():
            name2 += i.lower()
    stal = []
    for i in stations:
        each = ''
        for a in i:
            if a.isalnum():
                each += a.lower()
        stal += [[each,i]]
    l = []
    for i in stal:
        if name2 in i[0] :
            l += [i[1]]
    return l
def top_k_min_temp_stations(stations, K):
    pl = [] #ลิสต์เก็บคู่ชื่อสถานีกับtemp
    for i in stations:
        pl += [[stations[i]['temp'],i]]
    pl.sort()
    ans = [pl[i][1] for i in range(len(pl))][:K]
    return ans
def top_k_max_temp_stations(stations, K):
    pl = [] #ลิสต์เก็บคู่ชื่อสถานีกับtemp
    for i in stations:
        pl += [[-1*stations[i]['temp'],i]]
    pl.sort()
    ans = [pl[i][1] for i in range(len(pl))][:K]
    return ans
def peak_stations(stations):
    pl = [] #ลิสต์เก็บคู่ชื่อสถานีlatน้อยไปมาก
    for i in stations:
        pl += [[stations[i]['lat'],i]]
    pl.sort()
    pm = [] #ลิสต์เก็บคู่ชื่อสถานีlongน้อยไปมาก
    for i in stations:
        pm += [[stations[i]['long'],i]]
    pm.sort()
    ans = [pl[0][1],pl[len(pl)-1][1],pm[0][1],pm[len(pm)-1][1]]
    return ans
def k_nearby_stations(stations, main_station, K):
    lat1,long1 = stations[main_station]['lat'],stations[main_station]['long']
    distan = []
    for i in stations:
        if i != main_station:
            distan += [[distance(lat1, long1, stations[i]['lat'],stations[i]['long']),i]]
    distan1 = [sorted(distan)[i][1] for i in range(len(distan))]
    return distan1[:K]
def average_temp(stations, names):
    altemp = [stations[i]['temp'] for i in names]
    avtemp =sum(altemp)/len(names)
    return avtemp


# --------------------------------------------------
# 6330509621 (30) 327 (2021-03-29 15:53)

def approx_match(stations, name):
    ln = list(name)
    a =''
    b=''
    c=[]
    for e in ln:
        if e.isalpha():
            a += e.upper()

    for e in stations:
        if a in e.replace(' ','').upper():
            c += [e]


    return c
def top_k_min_temp_stations(stations, K):
    a = []
    for e in stations:
        a += [[stations[e]['temp'],e]]
    b = sorted(a)
    c=[]
    if K > len(b):
        k = len(b)
    else:
        k = K
    for e in range(k):
        c += [b[e][1]]
    return c
def top_k_max_temp_stations(stations, K):
    a = []
    for e in stations:
        a += [[-stations[e]['temp'],e]]
    b = sorted(a)
    c=[]
    if K > len(b):
        k = len(b)
    else:
        k=K
    for e in range(k):
        c += [b[e][1]]
    return c
def peak_stations(stations):
    a= []
    for e in stations:
        a += [[stations[e]['lat'],e]]
    lat = sorted(a)
    b=[]
    for e in stations:
        b += [[stations[e]['long'],e]]
    long = sorted(b)
    c=[lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return c
def k_nearby_stations(stations, main_station, K):
    a = []
    for e in stations:
        a += [[distance(float(stations[e]['lat']),float(stations[e]['long']),float(stations[main_station]['lat']),float(stations[main_station]['long'])),e]]
    b = sorted(a)[1:]
    c = []
    for e in range(K):
        c += [b[e][1]]
    return c
def average_temp(stations, names):
    a=[]
    for e in names:
        a += [stations[e]['temp']]
    b = 0
    for e in a:
        b += float(e)
    c = b/len(names)
    return c


# --------------------------------------------------
# 6330510121 (27.99) 328 (2021-03-29 17:32)

def approx_match(stations, name):
    x=name.upper().replace(' ','')
    a=[]
    for e in stations:
        if x in e:
            a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    x=sorted(stations,key=lambda x:stations[x]['temp'])
    for i in range(K):
        a.append(x[i])
        if len(a)==len(x):
            break
    a.sort()
    return a
def top_k_max_temp_stations(stations, K):
    a=[]
    x=sorted(stations,key=lambda x:stations[x]['temp'],reverse=True)
    for i in range(K):
        a.append(x[i])
        if len(a)==len(x):
            break
    a.sort()
    return a
def peak_stations(stations):
    a=[]
    a.append(min(stations,key=lambda x:stations[x]['lat']))
    a.append(max(stations,key=lambda x:stations[x]['lat']))
    a.append(min(stations,key=lambda x:stations[x]['long']))
    a.append(max(stations,key=lambda x:stations[x]['long']))
    return a
def k_nearby_stations(stations, main_station, K):
    a=[]
    for e in stations:
        if e!= main_station:
            a.append([distance(stations[main_station]['lat'],stations[main_station]['long'], stations[e]['lat'], stations[e]['long']),e])
    a.sort()
    a=a[:K]
    b=[]
    for i in a:
        b.append(i[1])

    return b
def average_temp(stations, names):
    a=0
    for e in names:
        a+=float(stations[e]['temp'])
    return a/len(names)


# --------------------------------------------------
# 6330511821 (30) 329 (2021-03-28 17:36)

def approx_match(stations, name):
    the_list = []
    name_string = ''
    for i in name.lower():
        if i == ' ':
            name_string += ''
        else:
            name_string += i.lower()
    for k in stations:
        j = k.upper()
        if name_string.upper() in j.replace(' ',''):
            the_list.append(k)
    return the_list
def top_k_min_temp_stations(stations, K):
    the_list = []
    stations_and_temp = sorted([[i,stations[i]['temp']] for i in stations])
    stations_and_temp = sorted([[i[1] ,i[0]] for i in stations_and_temp])
    for i in range(min(K,len(stations))):
        the_list.append(stations_and_temp[i][1])
    return the_list
def top_k_max_temp_stations(stations, K):
    the_list = []
    stations_and_temp = sorted([[i,stations[i]['temp']] for i in stations])
    stations_and_temp = sorted([[-i[1] ,i[0]] for i in stations_and_temp])
    for i in range(min(K,len(stations))):
        the_list.append(stations_and_temp[i][1])
    return the_list
def peak_stations(stations):
    the_list = []
    stations_and_temp = sorted([[stations[i]['lat'],i] for i in stations])
    the_list.append(stations_and_temp[0][1])
    the_list.append(stations_and_temp[-1][1])
    stations_and_temp = sorted([[stations[i]['long'],i] for i in stations])
    the_list.append(stations_and_temp[0][1])
    the_list.append(stations_and_temp[-1][1])
    return the_list
def k_nearby_stations(stations, main_station, K):
    the_list = []
    stations_and_distance = sorted([[distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i] for i in stations])[1::]
    for i in range(min(K,len(stations_and_distance))):
        the_list.append(stations_and_distance[i][1])
    return the_list
def average_temp(stations, names):
    temp = [stations[i]['temp'] for i in names]
    avg = sum(temp)/len(temp)
    return avg


# --------------------------------------------------
# 6330512421 (28.74) 330 (2021-03-29 11:13)

def approx_match(stations, name):
    name_ = ""
    for e in name :
        if "A"<=e.upper()<="Z" :
            name_ += e.upper()
    stations_ = {}
    for key in stations :
        key1 = ""
        key2 = ""
        for e in key :
            if "A"<=e.upper()<="Z" :
                key1 += e.upper()
                key2 += e.upper()
            else :
                key2 += e
        stations_[key1] = key2
    output = []
    for key1 in stations_ :
        if name_ in key1 :
            output += [stations_[key1]]
    return output
#------------------------------------------------
def top_k_min_temp_stations(stations, K):
    list_temp = sorted([stations[key]["temp"],key] for key in stations)
    output = []
    for i in range(K) :
        output += [list_temp[i][1]]
    return output
#------------------------------------------------
def top_k_max_temp_stations(stations, K):
    list_temp = sorted([stations[key]["temp"],key] for key in stations)[::-1]
    output = []
    for i in range(K) :
        output += [list_temp[i][1]]
    return output
#------------------------------------------------
def peak_stations(stations):
    list_lat = sorted([stations[key]["lat"],key] for key in stations)
    list_long = sorted([stations[key]["long"],key] for key in stations)
    output = []
    output += [list_lat[0][1]]
    output += [list_lat[-1][1]]
    output += [list_long[0][1]]
    output += [list_long[-1][1]]
    return output
#------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    list_dis = []
    for key in stations :
        d = distance(stations[main_station]["lat"],stations[main_station]["long"],stations[key]["lat"],stations[key]["long"])
        list_dis += [[float(d),key]]
    list_dis = sorted(list_dis)
    output = []
    for i in range(K+1) :
        output += [list_dis[i][1]]
    return output[1:]
#-----------------------------------------------
def average_temp(stations, names):
    s = 0
    n = 0
    for e in names :
        s += stations[e]["temp"]
        n += 1
    return s/n
# --------------------------------------------------
# 6330513021 (28.08) 331 (2021-03-29 21:27)

def approx_match(stations, name):
    stations_list=[]
    names=[]
    name=name.lower().split()
    no=''
    true_name=''
    for i in name:
        true_name+=i
    true_name=true_name.upper()
    for i in stations:
        x=i.split()
        for k in x:
            no+= k
            if true_name in no.upper():
                names.append(i)
                no=''
    return names
def top_k_min_temp_stations(stations, K):
    temp_list={}
    for i in stations:
        x=i
        y=stations[i]
        temp_list[i]=y['temp']
    list_sort_temp=sorted([ [ item[1], item[0] ] for  item in temp_list.items()])
    list_name=[]
    for i in range(len(list_sort_temp)):
        list_name.append(list_sort_temp[i][1])
    list_ans=list_name[:K]
    return list_ans
def top_k_max_temp_stations(stations, K):
    temp_list={}
    for i in stations:
        x=i
        y=stations[i]
        temp_list[i]=y['temp']
    list_sort_temp=sorted([ [ item[1], item[0] ] for  item in temp_list.items()],reverse = True)
    list_name=[]
    for i in range(len(list_sort_temp)):
        list_name.append(list_sort_temp[i][1])
    list_ans=list_name[:K]
    return list_ans
def peak_stations(stations):
    lat_list={}
    for i in stations:
        x=i
        y=stations[i]
        lat_list[i]=y['lat']
    list_sort_temp=sorted([ [ item[1], item[0] ] for  item in lat_list.items()],reverse = True)
    list_lat=[]
    for i in range(len(list_sort_temp)):
        list_lat.append(list_sort_temp[i][1])
    long_list={}
    for i in stations:
        x=i
        y=stations[i]
        long_list[i]=y['long']
    list_sort_long=sorted([ [ item[1], item[0] ] for  item in long_list.items()],reverse = True)
    list_long=[]
    for i in range(len(list_sort_long)):
        list_long.append(list_sort_long[i][1])
    list_ans=[list_lat[-1],list_lat[0],list_long[-1],list_long[0]]
    return list_ans
def k_nearby_stations(stations, main_station, K):
    main_latlong=[]
    x=stations[main_station]
    main_latlong.append(x['lat']),main_latlong.append(x['long'])
    dict_ans={}
    cal_latlong=[]
    for i in stations:
        y=stations[i]
        cal_latlong.append(y['lat']),cal_latlong.append(y['long'])
        dis=distance(main_latlong[0],main_latlong[1],cal_latlong[0],cal_latlong[1])
        dict_ans[i]=dis
        cal_latlong=[]
    list_sort_ans=sorted([ [ item[1], item[0] ] for  item in dict_ans.items()])[1:]
    list_sort_name=[]
    for i in range(len(list_sort_ans)):
        list_sort_name.append(list_sort_ans[i][1])
    ans=list_sort_name[:K]
    return ans
def average_temp(stations, names):
    temp_list={}
    for i in stations:
        x=i
        y=stations[i]
        temp_list[i]=y['temp']
    temp_no_cal=0
    list_temp_no_cal=[]
    for i in temp_list:
        if i in names:
            temp_no_cal+=temp_list[i]
            list_temp_no_cal.append(temp_list[i])
    temp_avg=temp_no_cal/len(list_temp_no_cal)
    return temp_avg


# --------------------------------------------------
# 6330514721 (30) 332 (2021-03-28 17:23)

def approx_match(stations, name):
    a=[]
    name=name.upper()
    name2=''
    for i in name:
        if not(i==' '):
            name2=name2+i
    for i in stations.keys():
        station_name=''
        for j in i:
            if not(j==' '):
                station_name=station_name+j
        station_name=station_name.upper()
        if name2 in station_name:
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    c=[[stations[i]["temp"],i] for i in stations]
    c=sorted(c)
    c=c[:K:]
    c=[c[e][1] for e in range(len(c))]
    return c
def top_k_max_temp_stations(stations, K):
    c=[[-stations[i]["temp"],i] for i in stations]
    c=sorted(c)
    c=c[:K:]
    c=[c[e][1] for e in range(len(c))]
    return c
def peak_stations(stations):
    c=[[stations[i]["lat"],i] for i in stations]
    c=sorted(c)
    m=c[0][1]
    d=c[-1][1]
    q=[[stations[i]["long"],i] for i in stations]
    q=sorted(q)
    f=q[0][1]
    l=q[-1][1]
    return [m,d,f,l]
def k_nearby_stations(stations, main_station, K):
    p=[[distance(stations[main_station]["lat"],stations[main_station]["long"],stations[i]["lat"],stations[i]["long"]),i] for i in stations]
    p=sorted(p)
    p=p[1:K+1:]
    p=[p[e][1] for e in range(len(p))]
    return p
def average_temp(stations, names):
    z=[]
    s=[stations[i]["temp"] for i in names]
    avr=(sum(s))/len(s)
    return avr
# --------------------------------------------------
# 6330516021 (25.98) 333 (2021-03-28 02:06)

def approx_match(stations, name):
    found = []
    search = name.upper()
    for k in stations :
        if search in k :
            found.append(k)
    return found
def top_k_min_temp_stations(stations, K):
    min_ = []
    for k in stations :
        min_.append([stations[k]['temp'],k])
    min_.sort()
    min_temp = []
    for e in min_ :
        min_temp += [e[1]]
    return min_temp[:K]
def top_k_max_temp_stations(stations, K):
    max_ = []
    for k in stations :
        max_.append([-stations[k]['temp'],k])
    max_.sort()
    max_temp = []
    for e in max_ :
        max_temp += [e[1]]
    return max_temp[:K]
def peak_stations(stations):
    peak_lat = []
    peak_long = []
    for k in stations :
        peak_lat += [[stations[k]['lat'],k]]
        peak_long += [[stations[k]['long'],k]]
    peak_lat.sort()
    peak_long.sort()
    return [peak_lat[0][1],peak_lat[-1][1],peak_long[0][1],peak_long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    near = []
    for k in stations :
        near += [[distance(stations[k]['lat'],stations[k]['long'],stations[main_station]['lat'],stations[main_station]['long']),k]]
    near.sort()
    near_stations = []
    for e in near :
        near_stations += [e[1]]
    return near_stations[1:K+1]
def average_temp(stations, names):
    average = 0
    for e in names :
        average += stations[e]['temp']
    return average/len(names)



# --------------------------------------------------
# 6330517621 (27) 334 (2021-03-27 17:42)

def approx_match(stations, name):
    name = name.lower()
    x = []
    y = []
    z = []

    for e in name:
        x.append(e)
    for e in x:
        if e == ' ':
            x.remove(e)
    c = ''.join(x)
    for key in stations:
        key = key.lower()
        if c in key:
            y.append(key)

    for m in y:
        z.append(m.upper())

    return z
def top_k_min_temp_stations(stations, K):
    x = []
    y = []
    z = []
    for key in stations:
        t = stations[key]['temp']
        x.append(t)
    x.sort()
    for e in x :
        if e not in z:
            z.append(e)
    r = z[:int(K)]
    for e in r:
        for key in stations:
            if e == stations[key]['temp']:
                y.append(key)
                break
    return y
def top_k_max_temp_stations(stations, K):
    x = []
    y = []
    z = []
    for key in stations:
        t = stations[key]['temp']
        x.append(t)
    x.sort()
    for e in x :
        if e not in z:
            z.append(e)
    r = z[:-(int(K)+1):-1]
    for e in r:
        for key in stations:
            if e == stations[key]['temp']:
                y.append(key)
                break
    return y
def peak_stations(stations):
    x = []
    stflat = []
    stflong = []
    for key in stations:
        la = stations[key]['lat']
        stflat.append(la)
    for key in stations:
        lo = stations[key]['long']
        stflong.append(lo)
    stflat.sort()
    stflong.sort()
    lat_min = stflat[0]
    lat_max = stflat[-1]
    long_min = stflong[0]
    long_max = stflong[-1]

    for key in stations:
        if lat_min == stations[key]['lat']:
            x.append(key)
            break
    for key in stations:
        if lat_max == stations[key]['lat']:
            x.append(key)
            break
    for key in stations:
        if long_min == stations[key]['long']:
            x.append(key)
            break
    for key in stations:
        if long_max == stations[key]['long']:
            x.append(key)
            break

    return x
def k_nearby_stations(stations, main_station, K):
    x = main_station.upper()
    y = []
    z = []
    lat1 = stations[x]['lat']
    long1 = stations[x]['long']
    for key in stations:
        lat2 = stations[key]['lat']
        long2 = stations[key]['long']
        ds = distance(lat1, long1, lat2, long2)
        y.append(ds)
    y.sort()
    r = y[:int(K)+1]
    for e in r:
        for key in stations:
            lat2 = stations[key]['lat']
            long2 = stations[key]['long']
            if e == distance(lat1, long1, lat2, long2) :
                z.append(key)
                break
    z.remove(x)

    return z
def average_temp(stations, names):
    total = 0
    i = 0
    for e in names:
        for key in stations:
            if key == e:
                t = stations[key]['temp']
                total += t
                i += 1
                break
    avg = (total)/i

    return avg

# --------------------------------------------------
# 6330518221 (30) 335 (2021-03-29 17:34)

def approx_match(stations, name):
    d = dict()
    out = list()
    for i in stations:
        d[cut(i).upper()] = i
    N = cut(name).upper()
    for i in d:
        if i.find(N) != -1:
            out.append(d[i])
    return out
def top_k_min_temp_stations(stations, K):
    min_t = sorted([[stations[a]['temp'],a] for a in stations])[:K]
    return [a for b,a in min_t]
def top_k_max_temp_stations(stations, K):
    max_t = sorted([[-stations[a]['temp'],a] for a in stations])[:K]
    return [a for b,a in max_t]
def peak_stations(stations):
    lat = sorted([[stations[a]['lat'],a] for a in stations])
    long = sorted([[stations[a]['long'],a] for a in stations])
    return [lat[0][1], lat[-1][1], long[0][1], long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    dis = sorted([[abs(distance(stations[a]['lat'],stations[a]['long'],stations[main_station]['lat'],stations[main_station]['long'])),a] for a in stations if a != main_station])[:K]
    return [a for b,a in dis]
def average_temp(stations, names):
    av = sum([stations[a]['temp'] for a in names]) / len(names)
    return av


# --------------------------------------------------
def cut(s):
    t = ''.join(s.split())
    return t
# 6330519921 (24) 336 (2021-03-29 21:14)

def approx_match(stations, name):
    name = name.upper().replace(" ","")
    result = []
    for station in stations:
        if name in station:
            result.append(station)
    return result
def top_k_min_temp_stations(stations, K):
    return sorted(stations, key=lambda x: stations[x]['temp'])[0:K]
def top_k_max_temp_stations(stations, K):
    return sorted(stations, key=lambda x: stations[x]['temp'], reverse = True)[0:K]
def peak_stations(stations):
    max_lat = max(stations, key=lambda k:float(stations[k]['lat']))
    min_lat = min(stations, key=lambda k:float(stations[k]['lat']))
    max_long = max(stations, key=lambda k:float(stations[k]['long']))
    min_long = min(stations, key=lambda k:float(stations[k]['long']))
    return [min_lat,max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    return sorted(stations, key= lambda d: distance(stations[d]['long'],
            stations[d]['lat'], stations[main_station]['long'],
            stations[main_station]['lat']))[0:K+1]
def average_temp(stations, names):
    total = 0
    for name in names:
        total += stations[name]['temp']

    average = total / len(names)
    return average

# --------------------------------------------------
# 6330520421 (24.32) 337 (2021-03-29 22:24)

def approx_match(stations, name):
    a = name.upper()
    b = a.replace(' ','')
    station_name = []
    for i in stations :
        if b in i:
            station_name.append(i)
    return station_name
def top_k_min_temp_stations(stations, K):
    station_temp = []
    for i in stations:
        temp = stations[i]['temp']
        station_temp.append([temp,i])
    a = sorted(station_temp)
    if len(a) >= K:
        return [a[i][1] for i in range(K)]
    else:
        return [a[i][1] for i in range(len(a))]
def top_k_max_temp_stations(stations, K):
    station_temp = []
    for i in stations:
        temp = stations[i]['temp']
        station_temp.append([temp,i])
    a = sorted(station_temp)[-1::-1]
    if len(a) >= K:
        return [a[i][1] for i in range(K)]
    else:
        return [a[i][1] for i in range(len(a))]
def peak_stations(stations):
    station_hlat = []
    for i in stations :
        lat = stations[i]['lat']
        station_hlat.append([lat,i])
    a = sorted(station_hlat)
    station_llat = []
    for i in stations :
        long = stations[i]['long']
        station_llat.append([long,i])
    b = sorted(station_llat)
    return [a[-1][1],a[0][1],b[-1][1],b[0][1]]
def k_nearby_stations(stations, main_station, K):
    d = []
    for i in stations:
        lat1 = float(stations[i]['lat'])
        long1 = float(stations[i]['long'])
        lat2 = float(stations[main_station]['lat'])
        long2 = float(stations[main_station]['long'])
        r= distance(lat1, long1, lat2, long2)
        if int(r) != 0 :
            d.append([r,i])
    dsorted = sorted(d)
    if len(d) >= K:
        return [dsorted[i][1] for i in range(K)]
    else:
        return [dsorted[i][1] for i in range(len(d))]
def average_temp(stations, names):
    temp = 0
    for i in names:
        temp += float(stations[i]['temp'])
    temp_av = temp/len(names)
    return temp_av


# --------------------------------------------------
# 6330521021 (28.74) 338 (2021-03-29 19:32)

def approx_match(stations, name):
    name=rawtext(name)
    allname=[]
    for s in stations:
        if name in rawtext(s):
            allname.append(s)
    return allname
def top_k_min_temp_stations(stations, K):
    temp,mintemp=[],[]
    for s in stations:
        temp.append([stations[s]['temp'],s])
    temp.sort()
    if len(temp) < K:
        N = len(temp)
    else:
        N = K
    for i in range(N):
        mintemp.append(temp[i][1])
    return mintemp
def top_k_max_temp_stations(stations, K):
    temp,mintemp=[],[]
    for s in stations:
        temp.append([stations[s]['temp'],s])
    temp.sort(reverse=True)
    if len(temp) < K:
        N = len(temp)
    else:
        N = K
    for i in range(N):
        mintemp.append(temp[i][1])
    return mintemp
def peak_stations(stations):
    lat,long=[],[]
    for s in stations:
        lat.append([stations[s]['lat'],s])
        long.append([stations[s]['long'],s])
    lat.sort()
    long.sort()
    peakstation=[lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return peakstation
def k_nearby_stations(stations, main_station, K):
    alllat,alllong,tdis,name,m=[],[],[],[],0
    for s in stations:
        alllat.append(stations[s]['lat'])
        alllong.append(stations[s]['long'])
    for i in stations:
        if i!=main_station:
            dis=[distance(stations[main_station]['lat'],stations[main_station]['long'],alllat[m],alllong[m]),i]
            tdis.append(dis)
        m+=1
    tdis.sort()
    for j in range(K):
        name.append(tdis[j][1])
    return name
def average_temp(stations, names):
    temp = []
    for name in names:
        temp.append(stations[name]['temp'])
    return sum(temp)/len(temp)

# --------------------------------------------------
def rawtext(text):
    text=text.upper().strip()
    ntext=''
    for i in text:
        if i.isalpha():
            ntext+=i
    return ntext
# 6330522721 (30) 339 (2021-03-29 23:58)

def approx_match(stations, name):

    nam = name.split()
    new_name = ''.join(nam).upper()
    list_station = []
    for k in stations:
        if new_name in remove_blank(k.upper()):
            list_station.append(k)
    return list_station
def top_k_min_temp_stations(stations, K):

    min_sta =[]
    sta_min = []
    for key in stations:
        min_sta.append([stations[key]['temp'],key])
    for temp,sta in sorted(min_sta)[:K]:
        sta_min.append(sta)
    return sta_min
def top_k_max_temp_stations(stations, K):

    max_sta = []
    for key in stations:
        max_sta.append([-stations[key]['temp'],key])
    max_sta.sort()
    real_max_sta = []
    for temp , sta in max_sta[:K]:
        real_max_sta.append(sta)
    return real_max_sta
def peak_stations(stations):

    lat = []
    long = []
    for key in stations :
        lat.append([stations[key]['lat'],key])
        long.append([stations[key]['long'],key])
    return [min(lat)[1] , max(lat)[1],min(long)[1], max(long)[1]]
def k_nearby_stations(stations, main_station, K):

    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    near_main = []
    for key in stations:
        lat_sta = stations[key]['lat']
        long_sta = stations[key]['long']
        near_main.append([distance( lat_main ,long_main , lat_sta, long_sta ),key])
    near_main.sort()
    near_main_sta = []
    for d , sta in near_main[1:K+1]:
        near_main_sta.append(sta)
    return near_main_sta
def average_temp(stations, names):
    sum_temp = 0
    for name in names:
        sum_temp += stations[name]['temp']
    return sum_temp / len(names)


# --------------------------------------------------
def remove_blank(key):
    s = ''
    for e in key :
        if e.isalpha():
            s += e
    return s
# 6330523321 (30) 340 (2021-03-27 19:31)

def approx_match(stations, name):
    name_upper_list = name.upper().split()
    name_upper = ''
    keynew =[]
    for i in name_upper_list:
        name_upper += i
    for e in stations:
        if name_upper in e:
            keynew.append(e)
    return keynew
def top_k_min_temp_stations(stations, K):
    celcius_list = []
    for i in stations.items():
        province = i[0]
        celcius = i[1]['temp']
        celcius_list.append([province,celcius])
    temperature_list = [[item[1],item[0]]for item in celcius_list]
    sort_temperature_list = sorted(temperature_list, key = lambda item: (item[0], item[1]))
    min_temperature_list  = sort_temperature_list[:K]
    onlyname_min_temperature_list = [item[1]for item in min_temperature_list]
    return onlyname_min_temperature_list
def top_k_max_temp_stations(stations, K):
    celcius_list = []
    for i in stations.items():
        province = i[0]
        celcius = i[1]['temp']
        celcius_list.append([province,celcius])
    sort_byname = sorted(celcius_list,reverse = True)
    temperature_list = ([[item[1],item[0]]for item in sort_byname])
    sort_temperature_list = sorted(temperature_list, key = lambda item: (-item[0], item[1]))
    min_temperature_list  = sort_temperature_list[:K]
    onlyname_min_temperature_list = [item[1]for item in min_temperature_list]
    return onlyname_min_temperature_list
def peak_stations(stations):
    min_lat = 90
    min_lat_stationname = ''
    max_lat = -90
    max_lat_stationname = ''
    min_long = 180
    min_long_stationname = ''
    max_long = -180
    max_long_stationname = ''
    for i in stations.items():
        province = i[0]
        Latitude = i[1]['lat']
        if Latitude < min_lat:
            min_lat = Latitude
            min_lat_stationname = province
        if Latitude > max_lat:
            max_lat = Latitude
            max_lat_stationname = province

        Longitude = i[1]['long']
        if Longitude < min_long:
            min_long = Longitude
            min_long_stationname = province
        if Longitude > max_long:
            max_long = Longitude
            max_long_stationname = province
    lat_long_name = [min_lat_stationname,max_lat_stationname,min_long_stationname,max_long_stationname]

    return lat_long_name
def k_nearby_stations(stations, main_station, K):
    lat_main_station =  stations[main_station]['lat']
    long_main_station =  stations[main_station]['long']
    distance_list = []
    for i in stations.items():
        province = i[0]
        if province != main_station:
            lat2 = i[1]['lat']
            long2 = i[1]['long']
            distance_value = distance(lat_main_station, long_main_station, lat2, long2)
            distance_list.append([distance_value,province])
    sort_distance_list = sorted(distance_list, key = lambda item: (item[0], item[1]))
    sort_distance_list_K = sort_distance_list[:K]
    only_name_distance_list_K = []
    for e in sort_distance_list_K:
        only_name_distance_list_K.append(e[1])
    return only_name_distance_list_K
def average_temp(stations, names):
    sum_tem = 0
    for i in stations.items():
        temperature = i[1]['temp']
        if i[0] in names:
            sum_tem += temperature
    average = sum_tem/len(names)
    return average


# --------------------------------------------------
# 6330524021 (30) 341 (2021-03-29 15:37)

def approx_match(stations, name):
    c=''.join(name.lower().split())
    return [e for e in stations if c in ''.join(e.lower().split())]
def top_k_min_temp_stations(stations, K):
    all_temp=[[stations[i]['temp'],i] for i in stations]
    all_temp.sort()
    if len(stations)<K: c=len(stations)
    else: c=K
    return [e[1] for e in all_temp[:c]]
def top_k_max_temp_stations(stations, K):
    all_temp=[[-stations[i]['temp'],i] for i in stations]
    all_temp.sort()
    if len(stations)<K: c=len(stations)
    else: c=K
    return [e[1] for e in all_temp[:c]]
def peak_stations(stations):
    min_lat=[[stations[e]['lat'],e] for e in stations];min_lat.sort()
    max_lat=[[-stations[e]['lat'],e] for e in stations];max_lat.sort()
    min_long=[[stations[e]['long'],e] for e in stations];min_long.sort()
    max_long=[[-stations[e]['long'],e] for e in stations];max_long.sort()
    return [min_lat[0][1],max_lat[0][1],min_long[0][1],max_long[0][1]]
def k_nearby_stations(stations, main_station, K):
    main_lat=stations[main_station]['lat']
    main_long=stations[main_station]['long']
    all_distances=list()
    for i in stations:
        if i != main_station:
            station_lat=stations[i]['lat']
            station_long=stations[i]['long']
            all_distances.append([distance(main_lat,main_long,station_lat,station_long),i])
    all_distances.sort()
    if len(stations)<K: c=len(stations)
    else: c=K
    return [e[1] for e in all_distances[:c]]
def average_temp(stations, names):
    temp_sum=sum([stations[e]['temp'] for e in names])
    return temp_sum/len(names)


# --------------------------------------------------
# 6330525621 (30) 342 (2021-03-29 20:43)

def approx_match(stations, name):
    new_name = ""
    for e in name:
        if e == " ":
            pass
        else:
            new_name += e
    match = []
    for e in stations:
        a = ""
        for i in e:
            if i.isalnum():
                a += i
        if new_name.upper() in a.upper():
            match.append(e)
    return match
def top_k_min_temp_stations(stations, K):
    stations_temp = []
    for e in stations:
        stations_temp.append([stations[e]['temp'],e])
    stations_temp.sort()
    stations_min_temp = []
    if K<len(stations_temp):
        for i in range(K):
            stations_min_temp.append(stations_temp[i][1])
    else:
        for i in range(len(stations_temp)):
            stations_min_temp.append(stations_temp[i][1])
    return stations_min_temp
def top_k_max_temp_stations(stations, K):
    stations_temp = []
    for e in stations:
        stations_temp.append([-stations[e]['temp'],e])
    stations_temp.sort()
    stations_max_temp = []
    if K < len(stations_temp):
        for i in range(K):
            stations_max_temp.append(stations_temp[i][1])
    else:
        for i in range(len(stations_temp)):
            stations_max_temp.append(stations_temp[i][1])
    return stations_max_temp
def peak_stations(stations):
    stations_lat = []
    stations_long = []
    for e in stations:
        stations_lat.append([stations[e]['lat'],e])
        stations_long.append([stations[e]['long'],e])
    stations_lat.sort()
    stations_long.sort()
    peak_stations = [stations_lat[0][1],stations_lat[-1][1],
                    stations_long[0][1],stations_long[-1][1]]
    return peak_stations
def k_nearby_stations(stations, main_station, K):
    main_lat,main_long = [stations[main_station]['lat'],
                     stations[main_station]['long']]
    station_lat_long = []
    for e in stations:
        station_lat_long.append([stations[e]['lat'],
                     stations[e]['long'],e])
    distance_to_main = []
    for e in station_lat_long:
        distance_to_main.append([distance(main_lat,main_long,e[0],e[1])
                                 ,e[2]])
    distance_to_main.sort()
    distance_to_main.pop(0)
    nearby_main = []
    if K<len(distance_to_main):
        for i in range(K):
            nearby_main.append(distance_to_main[i][1])
    else:
        for i in range(len(distance_to_main)):
            nearby_main.append(distance_to_main[i][1])
    return nearby_main
def average_temp(stations, names):
    temps = []
    for e in names:
        temps.append(stations[e]['temp'])
    sum_temp = 0
    for e in temps:
        sum_temp += e
    avg_temp = sum_temp/len(temps)
    return avg_temp
# --------------------------------------------------
# 6330526221 (24) 343 (2021-03-27 23:49)

def approx_match(stations, name):
    name = name.upper()
    a = ''
    b = []
    c = []
    for i in name :
        if not i == ' ' :
            a += i
    for i in stations :
        b.append(i)
    for e in range(len(b)) :
        if a in b[e] :
            c.append(b[e])
    return c
def top_k_min_temp_stations(stations, K):
    x = []
    y = []
    for e in stations :
        x.append([stations[e]['temp'],e])
    x.sort()
    if K > len(x) :
        K = len(x)
    for i in range(K) :
        y.append(x[i][1])
    return y
def top_k_max_temp_stations(stations, K):
    x = []
    y = []
    for e in stations :
        x.append([-stations[e]['temp'],e])
    x.sort()
    for i in range(len(x)) :
        x[i][0],x[i][1] = -x[i][0],x[i][1]
    if K > len(x) :
        K = len(x)
    for i in range(K) :
        y.append(x[i][1])
    return y
def peak_stations(stations):
    x = []
    y = []
    z = []
    for i in stations :
        x.append([stations[i]['lat'],i])
    x.sort()
    z.append(x[0][1])
    z.append(x[-1][1])
    for i in stations :
        y.append([stations[i]['long'],i])
    y.sort()
    z.append(y[0][1])
    z.append(y[-1][1])
    return z
def k_nearby_stations(stations, main_station, K):
    lat2 = []
    long2 = []
    x = []
    y = []
    z = []
    solution = []
    answer = []
    main_station = 'MAE HONG SON'
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for i in stations :
        lat2.append(stations[i]['lat'])
        long2.append(stations[i]['long'])
    for i in range(len(lat2)) :
        y.append(distance(lat1,long1,lat2[i],long2[i]))
    for i in stations :
        z.append(i)
    for i in range(len(y)) :
        solution.append([y[i],z[i]])
    solution.sort()
    if K > len(solution) :
        K = len(solution)
    for i in range(1,K+1) :
        answer.append(solution[i][1])
    return answer
def average_temp(stations, names):
    x = 0
    for i in range(len(names)) :
        x += stations[names[i]]['temp']
    x = x/len(names)
    return x

# --------------------------------------------------
# 6330527921 (30) 344 (2021-03-29 21:15)

def approx_match(stations, name):
    alname = ''
    for i in range(len(name)) :
        if name[i] != ' ' :
            alname += name[i]
    alname = alname.upper()
    lsta = [i for i in stations if alname in i.upper()]
    return lsta
def top_k_min_temp_stations(stations, K):
    minsta = [j[1] for j in sorted([[i[1]['temp'],i[0]]for i in stations.items()])[:K]]
    return  minsta
def top_k_max_temp_stations(stations, K):
    maxsta = [j[1] for j in sorted([[-i[1]['temp'],i[0]]for i in stations.items()])[:K]]
    return  maxsta
def peak_stations(stations):
    lat = sorted([[i[1]['lat'],i[0]] for i in stations.items()])
    long = sorted([[i[1]['long'],i[0]] for i in stations.items()])
    peak = [lat[0][1],lat[-1][1],long[0][1],long[-1][1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    ld =[]
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for i in stations :
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        d = distance(lat1, long1, lat2, long2)
        ld += [[d,i]]
    ld = [i[1] for i in sorted(ld)[1:K+1]]
    return ld
def average_temp(stations, names):
    avtemp = 0
    n = 0
    for i in names :
        avtemp += stations[i]['temp']
        n += 1
    avtemp = avtemp / n
    return avtemp

# --------------------------------------------------
# 6330528521 (30) 345 (2021-03-29 20:33)

def approx_match(stations, name):
    name = name.upper()
    b = ''
    v = []
    for i in name :
        if 'A'<= i <='z':
            b+=i
    for i in stations :
        if b in i :
            v.append(i)

    return v
def top_k_min_temp_stations(stations, K):
    n = []
    for i in stations:
        c = [stations[i]['temp'],i]
        n.append(c)
    n.sort()

    b = []
    for i in range(K):
        b.append(n[i][1])

    return b
def top_k_max_temp_stations(stations, K):
    n = []
    for i in stations:
        c = [-stations[i]['temp'],i]
        n.append(c)
    a = sorted(n)
    b = []
    for i in range(K):
        b.append(a[i][1])

    return b
def peak_stations(stations):
    b = []
    n = []
    for i in stations:
        c = [stations[i]['lat'],i]
        n.append(c)
    n.sort()
    b.append(n[0][1])
    b.append(n[-1][1])
    nn = []
    for i in stations:
        cc = [stations[i]['long'],i]
        nn.append(cc)
    nn.sort()
    b.append(nn[0][1])
    b.append(nn[-1][1])

    return b
def k_nearby_stations(stations, main_station, K):
    f = []
    for i in stations:
        x = [distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i]
        f.append(x)
    f.sort()
    c = []
    for i in range(1,K+1):
        c.append(f[i][1])

    return c
def average_temp(stations, names):
    a = 0
    for i in range(len(names)) :
        a+= stations[names[i]]['temp']
        if i == len(names)-1:
            b = a/(i+1)

    return b

# --------------------------------------------------
# 6330529121 (30) 346 (2021-03-29 20:00)

def approx_match(stations, name):
    name = ''.join(name.upper().split())
    match = []
    for station in stations :
        station_ = ''.join(station.upper().split())
        if name in station_:
            match.append(station)
    return match
def top_k_min_temp_stations(stations, K):
    l_stations = list(stations)
    def topMinTemp(e) :
        return stations[e]['temp'],e
    l_stations.sort(key = topMinTemp)
    return l_stations[:min(len(l_stations),K)]
def top_k_max_temp_stations(stations, K):
    l_stations = list(stations)
    def topMaxTemp(e) :
        return (-1)*stations[e]['temp'],e
    l_stations.sort(key = topMaxTemp)
    return l_stations[:min(len(l_stations),K)]
def peak_stations(stations):
    min_lat = getPeak(stations, 'lat')
    max_lat = getPeak(stations, 'lat', max=True)
    min_long = getPeak(stations, 'long')
    max_long = getPeak(stations, 'long', max=True)
    return [min_lat, max_lat, min_long, max_long]
def k_nearby_stations(stations, main_station, K):
    l_stations = list(stations)
    def stationD(e) :
        return distance(stations[main_station]['lat'], stations[main_station]['long'], stations[e]['lat'], stations[e]['long']), e
    top_near = sorted(l_stations,key=stationD)
    return top_near[min(1,len(top_near)):min(K+1,len(top_near))]
def average_temp(stations, names):
    sum = 0
    for e in names :
        sum += stations[e]['temp']
    ave = sum/len(names)
    return ave


# --------------------------------------------------
def getPeak(stations,L,max=False) :
    def minL(e) :
        return stations[e][L]
    def maxL(e) :
        return (-1)*stations[e][L]
    if not max :
        return sorted(stations, key = minL)[0]
    else: return sorted(stations, key = maxL)[0]
# 6330530721 (30) 347 (2021-03-28 00:50)

def approx_match(stations, name):
    list_of_appr = []
    li = []
    name = name.upper()
    name = name.replace(" ",'')
    for e in stations:
        list_of_appr.append(e)
    for i in range(len(list_of_appr)):
        if name in list_of_appr[i]:
            li.append(list_of_appr[i])
    return li
def top_k_min_temp_stations(stations, K):
    aa = []
    bb = []
    cc = []
    for key in stations:
        aa.append(stations[key]['temp'])
        bb.append(key)

    for i in range(len(aa)):
        cc.append([aa[i],bb[i]])
    cc.sort()
    dd = []
    if K > len(aa):
        for q in range(len(aa)):
            dd.append(cc[q][1])
    else:
        for k in range(K):
            dd.append(cc[k][1])
    return dd
def top_k_max_temp_stations(stations, K):
    aa = []
    bb = []
    cc = []
    for key in stations:
        aa.append(-stations[key]['temp'])
        bb.append(key)

    for i in range(len(aa)):
        cc.append([aa[i],bb[i]])
    cc.sort()
    dd = []
    if K > len(aa):
        for q in range(len(aa)):
            dd.append(cc[q][1])
    else:
        for k in range(K):
            dd.append(cc[k][1])

    return dd
def peak_stations(stations):

        aa = []
        bb = []
        cc = []
        dd = []
        for key in stations:
            aa.append(stations[key]['lat'])
            bb.append(key)

        for i in range(len(aa)):
            cc.append([aa[i],bb[i]])
        cc.sort()

        dd.append(cc[0][1])

        dd.append(cc[-1][1])


        xx = []
        yy = []
        zz = []

        for keyd in stations:
            xx.append(stations[keyd]['long'])
            yy.append(keyd)

        for u in range(len(xx)):
            zz.append([xx[u],yy[u]])
        zz.sort()

        dd.append(zz[0][1])

        dd.append(zz[-1][1])


        return dd
def k_nearby_stations(stations, main_station, K):
        xx = []
        yy = []
        zz = []
        dddis = []
        K +=1
        for key in stations:
            d = distance(stations[main_station]['lat'], stations[main_station]['long'], stations[key]['lat'],stations[key]['long'])
            dddis.append(d)
            yy.append(key)

        for i in range(len(dddis)):
            zz.append([dddis[i],yy[i]])
        zz.sort()
        dd = []
        if K > len(dddis)-1:
            for q in range(len(dddis)):
                dd.append(zz[q][1])
        else:
            for k in range(K):
                dd.append(zz[k][1])

        return dd[1:K]
def average_temp(stations, names):

    n=0
    for i in names:

        n+=stations[i]['temp']
    return n/len(names)


# --------------------------------------------------
# 6330531321 (30) 348 (2021-03-28 18:01)

def approx_match(stations, name):
    fullname = []
    station = []
    name = name.upper()
    for e in name:
        if  e != " ":
            fullname.append(e)
    fullname = "".join(fullname)
    for key in stations:
        if fullname in key:
            station.append(key)
    return station
def top_k_min_temp_stations(stations, K):
    n = 0
    tmp= []
    minimum = []
    for key in stations:
        temperature = [stations[key]["temp"],key]
        tmp.append(temperature)
        mintemp = sorted(tmp)
    for e in mintemp:
        if n != K:
           minimum.append(e[1])
           n += 1
        if n == K+1:
            break
    return minimum
def top_k_max_temp_stations(stations, K):
    m = 0
    tmp2 = []
    maximum = []
    for key in stations:
        temperature2 =[-(stations[key]["temp"]),key]
        tmp2.append(temperature2)
        tmp2.sort()
    for e in tmp2:
        if m != K:
           maximum.append(e[1])
           m += 1
        if m == K:
            break
    return maximum
def peak_stations(stations):
    latti = []
    longi = []
    peakstations = []
    for key in stations:
        latitude = [stations[key]["lat"],key]
        longitude = [stations[key]["long"],key]
        latti.append(latitude)
        longi.append(longitude)
        lattisort = sorted(latti)
        longisort = sorted(longi)
    latimin = lattisort[0][1]
    latimax = lattisort[-1][1]
    longimin = longisort[0][1]
    longimax = longisort[-1][1]
    peakstations.append(latimin)
    peakstations.append(latimax)
    peakstations.append(longimin)
    peakstations.append(longimax)
    return peakstations
def k_nearby_stations(stations, main_station, K):
    z =[]
    end = []
    x = stations[main_station]["lat"]
    y = stations[main_station]["long"]
    for e in stations:
        latti = stations[e]["lat"]
        longi = stations[e]["long"]
        z.append([distance(x,y,latti,longi),e])
    s = sorted(z)
    ss = s[1:K+1]
    for e in ss:
        saharatt = e[1]
        end.append(saharatt)
    return end
def average_temp(stations, names):
    summ = 0
    nn = len(names)
    for e in names:
        kite = stations[e.upper()]["temp"]
        summ += kite
    average = summ/nn
    return average


# --------------------------------------------------
# 6330532021 (30) 349 (2021-03-29 15:54)

def approx_match(stations, name):
    name__ = name.replace(' ','').upper()
    ans = []
    for key in stations:
        if name__ in key.replace(' ',''):
            ans.append(key)
    return ans
def top_k_min_temp_stations(stations, K):
    ans = []
    for i in stations:
        x = []
        x.append(stations[i]['temp'])
        x.append(i)
        ans.append(x)
    t = sorted(ans)[:K]
    ans_ = []
    for x,y in t:
        ans_.append(y)
    return ans_
def top_k_max_temp_stations(stations, K):
    ans = []
    for i in stations:
        x = []
        x.append(-stations[i]['temp'])
        x.append(i)
        ans.append(x)
    t = sorted(ans)[:K]
    ans_ = []
    for x,y in t:
        ans_.append(y)
    return ans_
def peak_stations(stations):
    ans = []
    for i in stations:
        x = []
        x.append(stations[i]['lat'])
        x.append(i)
        ans.append(x)
    lat0 = sorted(ans)[0][1]
    lat1 = sorted(ans)[-1][1]
    ans = []
    for i in stations:
        x = []
        x.append(stations[i]['long'])
        x.append(i)
        ans.append(x)
    long0 = sorted(ans)[0][1]
    long1 = sorted(ans)[-1][1]
    return [lat0,lat1,long0,long1]
def k_nearby_stations(stations, main_station, K):
    ans = []
    main_lat = stations[main_station]['lat']
    main_long =stations[main_station]['long']
    for i in stations:
        x = []
        x.append(distance(main_lat,main_long,stations[i]['lat'],stations[i]['long']))
        x.append(i)
        ans.append(x)
    o = sorted(ans)[1:K+1]
    ans_ = []
    for x,y in o:
        ans_.append(y)
    return ans_
def average_temp(stations, names):
    ans = []
    for i in stations:
        x = []
        x.append(stations[i]['temp'])
        x.append(i)
        ans.append(x)
    num = 0
    n = 0
    for x,y in ans:
        for i in names :
            if i == y:
                num += x
                n += 1
    return num/n

# --------------------------------------------------
# 6330533621 (30) 350 (2021-03-29 01:54)

def approx_match(stations, name):
  new_name=''
  s_stations=[]
  for i in list(name.upper()):
    if i != ' ':
      new_name+=i
  for e in stations.keys():
    if new_name in e:
      s_stations.append(e)
  return s_stations
def top_k_min_temp_stations(stations, K):
  temp_stations=[]
  for i in [e[0] for e in stations.items()]:
    temp_stations.append([stations[i]['temp'], i])
  temp_stations=sorted(temp_stations)
  last_temp_stations=[]
  for n in range(len([r[1] for r in temp_stations])):
    if 0<=n<=K-1:
      last_temp_stations.append([r[1] for r in temp_stations][n])
  return last_temp_stations
def top_k_max_temp_stations(stations, K):
  temp_stations=[]
  for i in [e[0] for e in stations.items()]:
    temp_stations.append([stations[i]['temp'], i])
  temp_stations=sorted([[-e[0],e[1]] for e in temp_stations])
  temp_stations=[[-e[0],e[1]] for e in temp_stations]
  last_temp_stations=[]
  for n in range(len([r[1] for r in temp_stations])):
    if 0<=n<=K-1:
      last_temp_stations.append([r[1] for r in temp_stations][n])
  return last_temp_stations
def peak_stations(stations):
  lat_stations=[]
  for i in [e[0] for e in stations.items()]:
    lat_stations.append([stations[i]['lat'], i])
  lat_stations=sorted(lat_stations)
  lat_stations=[lat_stations[0][1],lat_stations[-1][1]]

  long_stations=[]
  for i in [e[0] for e in stations.items()]:
    long_stations.append([stations[i]['long'], i])
  long_stations=sorted(long_stations)
  long_stations=[long_stations[0][1],long_stations[-1][1]]

  return lat_stations+long_stations
def k_nearby_stations(stations, main_station, K):
  dis_stations=[]
  for i in [e[0] for e in stations.items()]:
    dis_stations.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'],stations[i]['long']),i])
  dis_stations=sorted(dis_stations)

  last_dis_stations=[]
  for n in range(len(dis_stations)):
    if 1<=n<=K:
      last_dis_stations.append(dis_stations[n][1])
  return last_dis_stations
def average_temp(stations, names):
  temp=[]
  for i in names:
    temp.append(stations[i]['temp'])
  return sum(temp)/len(temp)


# --------------------------------------------------
# 6330534221 (30) 351 (2021-03-29 09:55)

def approx_match(stations, name):
    name=name.upper()
    namex=""
    for ch in name:
        if ch.isalpha()==True:
            namex+= ch
    sta_name=[e for e in stations if namex in e]
    return sta_name
def top_k_min_temp_stations(stations, K):
    sta_temp=[]
    for e in stations:
        sta_temp+=[[stations[e]["temp"],e]]
    sta_temp.sort()
    if int(K)>len(sta_temp):
        n=[e[1] for e in sta_temp]
    else:
        n=[e[1] for e in sta_temp[:int(K)]]
    return n
def top_k_max_temp_stations(stations, K):
    sta_temp=[]
    for e in stations:
        sta_temp+=[[-(stations[e]["temp"]),e]]
    sta_temp.sort()

    if int(K)>len(sta_temp):
        n=[e[1] for e in sta_temp]
    else:
        n=[e[1] for e in sta_temp[:int(K)]]
    return n
def peak_stations(stations):
    sta_lat=[]
    sta_long=[]
    for e in stations:
        sta_lat+=[[(stations[e]["lat"]),e]]
    sta_lat.sort()
    for e in stations:
        sta_long+=[[(stations[e]["long"]),e]]
    sta_lat.sort()
    sta_long.sort()
    return [sta_lat[0][1],sta_lat[-1][1],sta_long[0][1],sta_long[-1][-1]]
def k_nearby_stations(stations, main_station, K):
    main_station=main_station.upper()
    sta_main=[main_station,stations[main_station]["lat"],stations[main_station]["long"]]
    sta_lo=[[e,stations[e]["lat"],stations[e]["long"]] for e in stations]
    sta_dis=[]
    for e in sta_lo:
        sta_dis+=[[distance(sta_main[1],sta_main[2],e[1],e[2]),e[0]]]
    sta_dis.sort()
    if int(K)+1>len(sta_dis):
        n=[e[1] for e in sta_dis[1:]]
    else:
        n=[e[1] for e in sta_dis[1:int(K)+1]]

    return n
def average_temp(stations, names):
    sta_temp=[stations[e]["temp"] for e in names]

    return sum(sta_temp)/len(names)


# --------------------------------------------------
# 6330535921 (30) 352 (2021-03-28 02:04)

def approx_match(stations, name):
    lis =[]
    name = ''.join(name.split(' ')).upper()
    for i in stations :
        if name in i :
            lis.append(i)
    return lis
def top_k_min_temp_stations(stations, K):
    lis = []
    for name in stations:
        lis.append([stations[name]['temp'],name])
    lis = sorted(lis)
    return count(lis,K)
def top_k_max_temp_stations(stations, K):
    lis = []
    for name in stations:
        lis.append([-stations[name]['temp'],name])
    lis.sort()
    return count(lis,K)
def peak_stations(stations):
    lat =[]
    long = []
    ans = []
    for name in stations:
        lat.append([stations[name]['lat'],name])
        long.append([stations[name]['long'],name])
    ans.append(min(lat)[1])
    ans.append(max(lat)[1])
    ans.append(min(long)[1])
    ans.append(max(long)[1])
    return ans
def k_nearby_stations(stations, main_station, K):
    main = stations[main_station.upper()]
    dis = []
    for item in stations:
        if main_station.upper() != item:
            dis.append([distance(main['lat'],main['long'],stations[item]['lat'],stations[item]['long']),item])
    dis.sort()
    return count(dis,K)
def average_temp(stations, names):
    temp = []
    for item in names:
        temp.append(stations[item]['temp'])
    ans = sum(temp)/len(temp)
    return ans

# --------------------------------------------------
def count(lis,K):
    ans = []
    for i in range(len(lis)):
        if i < K :
            ans.append(lis[i][1])
    return ans
# 6330536521 (30) 353 (2021-03-28 15:27)

def approx_match(stations, name):
    a=[]
    names=""
    for e in name:
        if e!=" ":
            names+=e
    for e in stations:
        if names.upper() in e.upper():
            a.append(e)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    for e in stations:
        a.append([stations[e]["temp"],e])
    a=[e[1] for e in sorted(a) ]
    return a[:K]
def top_k_max_temp_stations(stations, K):
    a=[]
    for e in stations:
        a.append([stations[e]["temp"],e])
    a=[b[1] for b in sorted([-e[0],e[1]] for e in a) ]
    return a[:K]
def peak_stations(stations):
    a=[]
    b=[]
    for e in stations:
        a.append([stations[e]["lat"],e])
        b.append([stations[e]["long"],e])
    a.sort()
    b.sort()
    return [a[0][1],a[-1][1],b[0][1],b[-1][1]]
def k_nearby_stations(stations, main_station, K):
    d=[]
    for e in stations:
        d.append([distance(stations[e]["lat"],stations[e]["long"],stations[main_station]["lat"],stations[main_station]["long"]),e])
    d=[e[1] for e in sorted(d) ]
    return d[1:K+1]
def average_temp(stations, names):
    a=0
    i=0
    for e in names:
        a+=stations[e]["temp"]
        i+=1
    return a/i

# --------------------------------------------------
# 6330537121 (29.6) 354 (2021-03-28 22:04)

def approx_match(stations, name):
   name=name.upper().split()
   name =''.join(name)
   b=[]
   for i in stations:
     if name in i:
        b.append(i)
   return b
def top_k_min_temp_stations(stations, K):
   b = []
   d = []
   for i in stations:
     c = [stations[i]['temp'],i]
     b.append(c)
     b.sort()
   for e in b:
     d.append(e[1])

   a = d[:K]

   return a
def top_k_max_temp_stations(stations, K):
    s = []
    d = []

    for i in stations:
       c = [stations[i]['temp']*-1,i]
       s.append(c)
    s.sort()

    for i in s:
      d.append(i[1])

    s=d[:K]
    return s
def peak_stations(stations):
   b=[]
   f=[]
   d=[]
   e=[]
   r=[]
   p=[]
   for i in stations:
      c = [stations[i]['lat'],i]

      f.append(c)
      f.sort()

   for i in f:
      c = i[1]
      r.append(c)

   for e in stations:
      c=[stations[e]['long'],e]
      d.append(c)
      d.sort()

   for e in d:
      c = e[1]
      p.append(c)
   min_lat = r[0]
   max_lat = r[len(r)-1]
   min_long = p[0]
   max_long = p[len(p)-1]
   return min_lat,max_lat,min_long,max_long
def k_nearby_stations(stations, main_station, K):
   b=[]
   f=[]
   g=[]
   for i in stations:
      lat1 = stations[i]['lat']
      long1 =stations[i]['long']
      lat2 = stations[main_station]['lat']
      long2  = stations[main_station]['long']
      rayatang = distance(lat1, long1, lat2, long2)
      b.append([rayatang,i])
   b.sort()
   for e in b:
       f.append(e[1])



   return f[1:K+1]
def average_temp(stations, names):
    a=0
    for i in names:
        a += float(stations[i]['temp'])
    b = a/len(names)
    return b


# --------------------------------------------------
# 6330538821 (28.74) 355 (2021-03-28 13:09)

def approx_match(stations, name):
    a=''
    out=[]
    for i in name:
        if i.lower() in 'abcdefghijklmnopqrstuvwxyz':
            a += i.lower()
        else:
            a += ""
    for j in stations:
        if a in j.lower():
            out.append(str(j))
    return out
def top_k_min_temp_stations(stations, K):
    a=dict()
    o=[]
    for i in stations:
        a[i] = stations[i]['temp']
    out =[[-p[0],p[1]]for p in sorted(([-j[1],j[0]] for j in a.items()),reverse=True)]
    if int(K) > len(out):
        K = len(out)
    for j in range (K):
        o.append(str(out[j][1]))
    return o
def top_k_max_temp_stations(stations, K):
    a=dict()
    o=[]
    for i in stations:
        a[i] = stations[i]['temp']
    out =[[-p[0],p[1]]for p in sorted(([-j[1],j[0]] for j in a.items()))]
    if int(K) > len(out):
        K = len(out)
    for j in range (K):
        o.append(str(out[j][1]))
    return o
def peak_stations(stations):
    a=dict()
    b=dict()
    outtt=[]
    for i in stations:
        a[i] = stations[i]['lat']
    out =sorted(([j[1],j[0]] for j in a.items()))
    n=len(out)
    q=str(out[0][1])
    qq=str(out[n-1][1])
    outtt.append(q)
    outtt.append(qq)
    for j in stations:
        b[j] = stations[j]['long']
    outt =sorted(([jj[1],jj[0]] for jj in b.items()))
    nn=len(outt)
    w=str(outt[0][1])
    ww=str(outt[nn-1][1])
    outtt.append(w)
    outtt.append(ww)
    return outtt
def k_nearby_stations(stations, main_station, K):
    a=dict()
    g=[]
    for i in stations:
        a[i]=distance(float(stations[main_station]['lat']), float(stations[main_station]['long']), float(stations[i]['lat']), float(stations[i]['long']))
    out=[[-p[0],p[1]]for p in sorted(([-j[1],j[0]] for j in a.items()),reverse=True)]
    if int(K) > len(out):
        K = len(out)
    for j in range (K+1):
        q=str(out[j][1])
        if q != main_station :
            g.append(q)
    return g
def average_temp(stations, names):
    a=0
    for i in names:
        a += float(stations[i]['temp'])
    a = a/(len(names))
    return a
    for j in names:
        print(j,str(stations[j]['temp'])+'°c')

# --------------------------------------------------
# 6330539421 (24.32) 356 (2021-03-29 16:47)

def approx_match(stations, name):
    a = []
    for i in stations:
        if name.lower().replace(' ','') in i.lower().replace(' ',''):
            a.append(i.upper())
    return a
def top_k_min_temp_stations(stations, K):
    if K < len(stations):
        a = [m[1] for m in sorted([[stations[i]['temp'],i] for i in stations])][:K]
    else:
        a = [m[1] for m in sorted([[stations[i]['temp'],i] for i in stations])]
    return a
def top_k_max_temp_stations(stations, K):
    if K < len(stations):
        a = [m[1] for m in sorted([[stations[i]['temp'],i] for i in stations],reverse=True)][:K]
    else:
        a = [m[1] for m in sorted([[stations[i]['temp'],i] for i in stations],reverse=True)]
    return a
def peak_stations(stations):
    a = []
    for i in stations:
        if a == []:
            a = [i,i,i,i]
        if stations[i][lat] < stations[a[0]][lat]:
            a[0] = i
        elif stations[i][lat] == stations[a[0]][lat] and i < a[0]:
            a[0] = i
        if stations[i][lat] > stations[a[1]][lat]:
            a[1] = i
        elif stations[i][lat] == stations[a[1]][lat] and i < a[1]:
            a[1] = i
        if stations[i][long] < stations[a[2]][long]:
            a[2] = i
        elif stations[i][long] == stations[a[2]][long] and i < a[2]:
            a[2] = i
        if stations[i][long] > stations[a[3]][long]:
            a[3] = i
        elif stations[i][long] == stations[a[3]][long] and i < a[3]:
            a[3] = i
def k_nearby_stations(stations, main_station, K):
    a = []
    for i in stations:
        if i != main_station:
            a.append([distance(stations[i]['lat'],stations[i]['long'],stations[main_station]['lat'],stations[main_station]['long']),i])
    if K < len(stations):
        b = [m[1] for m in sorted(a)][:K]
    else:
        b = [m[1] for m in sorted(a)]
    return b
def average_temp(stations, names):
    a = 0
    for i in names:
        a += stations[i]['temp']
    a = a/len(names)
    return a
# --------------------------------------------------
# 6330540021 (27) 357 (2021-03-29 23:31)

def approx_match(stations, name):
    result = []
    search_text = "".join([c.lower() for c in name if c != " "])
    for _name in stations:
        if search_text in "".join([c.lower() for c in _name if c != " "]):
            result.append(_name)
    result.sort()
    return result
def top_k_min_temp_stations(stations, K):
    temp_list = []
    for _name in stations:
        temp_list.append([stations[_name]["temp"], _name])
    temp_list.sort()
    return [a for _, a in temp_list][:K]
def top_k_max_temp_stations(stations, K):
    temp_list = []
    for _name in stations:
        temp_list.append([stations[_name]["temp"], _name])
    return [a for _, a in sorted(temp_list)][:K]
def peak_stations(stations):
    lat_list = sorted([[stations[_name]["lat"], _name] for _name in stations])
    lowest_lat = lat_list[0][1]
    highest_lat = lat_list[-1][1]
    long_list = sorted([[stations[_name]["long"], _name]
                        for _name in stations])
    lowest_long = long_list[0][1]
    highest_long = long_list[-1][1]
    return [lowest_lat, highest_lat, lowest_long, highest_long]
def k_nearby_stations(stations, main_station, K):
    main_station_lat = stations[main_station]["lat"]
    main_station_long = stations[main_station]["long"]
    distance_list = [[distance_from_main(stations, main_station_lat, main_station_long, _name), _name]
                     for _name in stations if main_station != _name]
    return [_name for _, _name in sorted(distance_list)][:K]
def average_temp(stations, names):
    return sum([stations[n]["temp"] for n in names]) / len(names)


# --------------------------------------------------
def distance_from_main(stations, lat, long, dist):
    return distance(stations[dist]["lat"], stations[dist]["long"], lat, long)
# 6330541621 (30) 358 (2021-03-29 22:21)

def approx_match(stations, name):
    lst = []
    lst2 = ''
    A1 = name.upper()
    A2 = A1.split()
    for i in range(len(A2)):
        lst.append(A2[i])
    for i in range(len(lst)):
        lst2 += lst[i]
    lst3 = []
    for key in stations:
        if lst2 in key:
            lst3.append(key)
    return lst3
def top_k_min_temp_stations(stations, K):
    lst = []
    lst2 = []
    lst3 = []
    for key in stations:
        for key2 in stations[key]:
            if key2 == 'temp':
                lst2.append(stations[key][key2])
                lst.append(key)
    for i in range(len(lst)):
        lst3.append([lst2[i],lst[i]])
    lst3.sort()
    lst4 = []
    for i in range(len(lst3)):
        if len(lst3) < K:
            lst4 = lst3[0:]
        elif len(lst3) >= K:
            lst4 = lst3[0:K]
    lst5 = []
    for i in range(len(lst4)):
        lst5.append(lst4[i][1])
    return lst5
def top_k_max_temp_stations(stations, K):
    lst = []
    lst2 = []
    lst3 = []
    for key in stations:
        for key2 in stations[key]:
            if key2 == 'temp':
                lst2.append(stations[key][key2])
                lst.append(key)
    for i in range(len(lst)):
        lst3.append([lst2[i],lst[i]])
    lst3.sort()
    lst4 = []
    for i in range(len(lst3)):
        lst4 = lst3[::-1]
    for i in range(len(lst4)):
        lst4[i][0] = -1*lst4[i][0]
    lst4.sort()
    for i in range(len(lst4)):
        lst4[i][0] = -1*lst4[i][0]
    lst5 = []
    for i in range(len(lst4)):
        if len(lst4) < K:
            lst5 = lst4[0:]
        elif len(lst4) >= K:
            lst5 = lst4[0:K]
    lst6 = []
    for i in range(len(lst5)):
        lst6.append(lst5[i][1])
    return lst6
def peak_stations(stations):
    stat = list(stations)
    mnlat = min([[stations[i]['lat'],i] for i in stat])
    mxlat = max([[stations[i]['lat'],i] for i in stat])
    mnlong = min([[stations[i]['long'],i] for i in stat])
    mxlong = max([[stations[i]['long'],i] for i in stat])
    peak = [mnlat[1],mxlat[1],mnlong[1],mxlong[1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    stat = list(stations)
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    statdis = [[distance(lat1,long1,stations[i]['lat'],stations[i]['long']),i] for i in stat]
    statdis2 = sorted(statdis)[1:K+1]
    statdisname = [i[1] for i in statdis2]
    return statdisname
def average_temp(stations, names):
    temp = [stations[i]['temp'] for i in names]
    average = ((round(sum(temp),2))/(len(temp)))
    return average

# --------------------------------------------------
# 6330542221 (28.14) 359 (2021-03-29 00:54)

def approx_match(stations, name):
    n = name.replace(' ','').lower()
    match = []
    for i in [item for item in stations.keys()]:
        s = i.lower()
        if n in s :
            match.append(i)
    return match
def top_k_min_temp_stations(stations, K):
    temp = []
    for i in [item for item in stations.keys()]:
        a = stations[i]['temp']
        temp.append([a,i])
    temp.sort()
    c = [item[1] for item in temp]
    if K<=len(c):
        return c[:K]
    else :
        return c[0:]
def top_k_max_temp_stations(stations, K):
    temp = []
    for i in [item for item in stations.keys()]:
        a = stations[i]['temp']
        temp.append([a,i])
    b = sorted(temp,reverse=True)
    c = [item[1] for item in b]
    if K<=len(c):
        return c[:K]
    else :
        return c[0:]
def peak_stations(stations):
    lat = []
    for i in [item for item in stations.keys()]:
        a = stations[i]['lat']
        lat.append([a,i])
    lat_min = sorted(lat)[0][1]
    lat_max = sorted(lat,reverse=True)[0][1]

    long = []
    for i in [item for item in stations.keys()]:
        a = stations[i]['long']
        long.append([a,i])
    long_min = sorted(long)[0][1]
    long_max = sorted(long,reverse=True)[0][1]
    return lat_min,lat_max,long_min,long_max
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    nearby = []
    for i in stations:
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        dis = distance(lat1,long1,lat2,long2)
        nearby.append([dis,i])
    nearby.sort()
    nearby_sta = [sta[1] for sta in nearby[1:]]

    if K<=len(nearby_sta):
        return nearby_sta[0:K]
    else:
        return nearby_sta[0:]
def average_temp(stations, names):
    a = 0
    for i in names:
        a += stations[i]['temp']
    avg = a/len(names)
    return avg

# --------------------------------------------------
# 6330543921 (30) 360 (2021-03-28 21:19)

def approx_match(stations, name):
    out = ''
    for c in name:
        if c.upper() in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
            out += c.upper()

    names = []
    for key in stations:
        if out in key or name.upper() in key:
            names.append(key)
    return names
def top_k_min_temp_stations(stations, K):

    if K > len(stations):
        K = len(stations)

    tstations = []
    for key in stations:
        tstations.append(key)
    tstations = sorted(tstations)

    temp = dict()
    for station in tstations:
        if station in stations:
            temp[station] = float(stations[station]['temp'])

    lists = sorted([(item[1], item[0]) for item in temp.items()])[0:K]

    top_k_min_temp = []
    for list in lists:
        top_k_min_temp.append(list[1])
    return top_k_min_temp
def top_k_max_temp_stations(stations, K):

    if K > len(stations):
        K = len(stations)

    tstations = []
    for key in stations:
        tstations.append(key)
    tstations = sorted(tstations)

    temp_stations = []
    temp = []
    lists_station = []
    for station in tstations:
        temp_stations.append((station, stations[station]['temp']))
        temp.append(stations[station]['temp'])

    temps = sorted(temp, reverse = True)
    for i in range(len(temps)):
        for j in range(len(temp_stations)):
            if temps[i] == temp_stations[j][1] and temp_stations[j][0] not in lists_station:
                lists_station.append(temp_stations[j][0])

    top_k_max_temp = []
    top_k_max_temp = lists_station[0:K]

    return top_k_max_temp
def peak_stations(stations):

    tstations = []
    for key in stations:
        tstations.append(key)
    tstations = sorted(tstations)

    lat_temp = dict()
    long_temp = dict()
    for station in tstations:
        if station in stations:
            lat_temp[station] = float(stations[station]['lat'])
            long_temp[station] = float(stations[station]['long'])

    lat_lists = sorted([(item[1], item[0]) for item in lat_temp.items()])
    long_lists = sorted([(item[1], item[0]) for item in long_temp.items()])
    peak_stations = []
    peak_stations.append(lat_lists[0][1])
    peak_stations.append(lat_lists[len(lat_lists)-1][1])
    peak_stations.append(long_lists[0][1])
    peak_stations.append(long_lists[len(long_lists)-1][1])
    return peak_stations
def k_nearby_stations(stations, main_station, K):

    if K > len(stations):
        K = len(stations)

    tstations = []
    for key in stations:
        tstations.append(key)
    tstations = sorted(tstations)

    f_lat = stations[main_station]['lat']
    f_long = stations[main_station]['long']

    nearby_stations = dict()
    for station in tstations:
        if station in stations and station != main_station:
            distance = ((stations[station]['lat'] - f_lat)**2 + (stations[station]['long'] - f_long)**2)**(1/2)
            nearby_stations[station] = distance

    lists = sorted([[item[1], item[0]] for item in nearby_stations.items()])[0:K]

    k_nearby_stations = []
    for list in lists:
        k_nearby_stations.append(list[1])

    return k_nearby_stations
def average_temp(stations, names):

    sumtemp = 0
    for name in names:
        if name in stations:
            sumtemp += float(stations[name]['temp'])

    average = sumtemp/len(names)

    return average


# --------------------------------------------------
# 6330544521 (30) 361 (2021-03-28 21:25)

def approx_match(stations, name):

    names = []
    x =''
    for c in name:
        if 'A' <= c.upper() <= 'Z':
            x += c.upper()

    for key in stations:
        if x in key or name.upper() in key:
            names.append(key)
    return names
def top_k_min_temp_stations(stations, K):

    t_stations = []
    temp_stations = []
    top_k_min_temp = []

    for key in stations:
        t_stations.append(key)
    t_stations = sorted(t_stations)

    for t_station in t_stations:
        if t_station in stations:
            temp_stations.append((t_station, stations[t_station]['temp']))

    if K > len(stations):
        K = len(stations)
    lists = sorted([(i[1], i[0]) for i in temp_stations])[0:K]

    for list in lists:
        top_k_min_temp.append(list[1])

    return top_k_min_temp
def top_k_max_temp_stations(stations, K):

    t_stations = []
    temp_stations = []
    temp = []
    lists_station = []

    for key in stations:
        t_stations.append(key)
    t_stations = sorted(t_stations)

    for station in t_stations:
        temp_stations.append((station, stations[station]['temp']))
        temp.append(stations[station]['temp'])

    temps = sorted(temp)[::-1]
    for temp in temps:
        for temp_station in temp_stations:
            if temp == temp_station[1] and temp_station[0] not in lists_station:
                lists_station.append(temp_station[0])

    if K > len(stations):
        K = len(stations)
    lists_station = lists_station[0:K]

    return lists_station
def peak_stations(stations):

    t_stations = []
    lat = []
    long = []
    peak_stations = []

    for key in stations:
        t_stations.append(key)
    t_stations = sorted(t_stations)

    for t_station in t_stations:
        if t_station in stations:
            lat.append((t_station, stations[t_station]['lat']))
            long.append((t_station, stations[t_station]['long']))

    lat_lists = sorted([(i[1], i[0]) for i in lat])
    long_lists = sorted([(i[1], i[0]) for i in long])

    peak_stations.append(lat_lists[0][1])
    peak_stations.append(lat_lists[::-1][0][1])
    peak_stations.append(long_lists[0][1])
    peak_stations.append(long_lists[::-1][0][1])

    return peak_stations
def k_nearby_stations(stations, main_station, K):

    t_stations = []
    nearby_stations = []
    k_nearby_stations = []

    for key in stations:
        t_stations.append(key)
    t_stations = sorted(t_stations)

    for station in t_stations:
        if station in stations and station != main_station:
            nearby_stations.append((station, ((stations[station]['lat'] - stations[main_station]['lat'])**2 + (stations[station]['long'] - stations[main_station]['long'])**2)**(1/2)))

    if K > len(stations):
        K = len(stations)
    lists = sorted([[i[1], i[0]] for i in nearby_stations])[0:K]

    for list in lists:
        k_nearby_stations.append(list[1])

    return k_nearby_stations
def average_temp(stations, names):

    sum_temp = 0
    for name in names:
        if name in stations:
            sum_temp += float(stations[name]['temp'])

    average = sum_temp/len(names)

    return average


# --------------------------------------------------
# 6330545121 (28.14) 362 (2021-03-29 20:13)

def approx_match(stations, name):

    a = []
    name2 = name.upper()
    name1 = ''.join(name.split()).upper()
    for i in stations:
        if name2 in i or name1 in i:
            a.append(i)
    return a
# stations เป็น dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
 # name เป็นสตริง
 # คืนลิสต์ที่เก็บชื่อสถานีที่มีตัวอักษรใน name เป็นส่วนหนึ่งของชื่อสถานี โดยไม่สนใจว่า
 # เป็นตัวพิมพ์เล็กหรือใหญ่ และไม่สนใจเว้นวรรคภายในด้วย (ชื่อในลิสต์ที่คืนเป็นผลลัพธ์เรียงอย่างไรก็ได้)
 # หมายเหตุ: ชื่อสถานีที่เป็นคีย์ใน stations นั้นเป็นตัวพิมพ์ใหญ่หมด ผลที่คืนจากฟังก์ชันนี้ก็จะเก็บตัวพิมพ์ใหญ่
 # แต่ตอนค้น name ใน stations นั้น ต้องเป็นแบบไม่สนใจว่าเป็นตัวพิมพ์เล็กหรือใหญ่
 # เช่น name = 'Tha ni' จะได้ผลลัพธ์เป็นดังนี้ (เรียงลำดับอื่นก็ได้)
 # ['UDON THANI', 'UBON RATCHATHANI AGROMET.', 'UBON RATCHATHANI',
 # 'UTHAITHANI', 'PATHUMTHANI', 'SURAT THANI', 'SURAT THANI AGROMET.']
def top_k_min_temp_stations(stations, K):
    a = []
    stations = sorted([[i[1]['temp'],i[0]] for i in stations.items()])[:K]
    for i in stations:
        a.append(i[1])
    return a
 # stations เป็น dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้, K เป็นจำนวนเต็มบวก
 # คืนลิสต์ของชื่อสถานีที่มีอุณหภูมิต่ำสุด K สถานี ให้เรียงจากซ้ายไปขวาตามสถานีที่มีอุณหภูมิต่ำสุดไปสูงขึ้น
 # ในกรณีที่มีอุณหภูมิเท่ากัน ให้เลือกสถานีที่มีชื่อมาก่อนตามลำดับในพจนานุกรม ในกรณีที่มีไม่ถึง K สถานี ก็คืนเท่าที่มี
def top_k_max_temp_stations(stations, K):
    a = []
    stations = sorted([[i[1]['temp'],i[0]] for i in stations.items()],reverse = True)[:K]
    for i in stations:
        a.append(i[1])
    return a
# stations เป็น dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้, K เป็นจำนวนเต็มบวก
 # คืนลิสต์ของชื่อสถานีที่มีอุณหภูมิสูงสุด K สถานี ให้เรียงจากซ้ายไปขวาตามสถานีที่มีอุณหภูมิสูงสุดไปต่ำลง
 # ในกรณีที่มีอุณหภูมิเท่ากัน ให้เลือกสถานีที่มีชื่อมาก่อนตามลำดับในพจนานุกรม ในกรณีที่มีไม่ถึง K สถานี ก็คืนเท่าที่ม
def peak_stations(stations):
    a = sorted([[i[1]['lat'],i[0]] for i in stations.items()])[0][1]
    b = sorted([[i[1]['lat'],i[0]] for i in stations.items()],reverse = True)[0][1]
    c = sorted([[i[1]['long'],i[0]] for i in stations.items()])[0][1]
    d = sorted([[i[1]['long'],i[0]] for i in stations.items()],reverse = True)[0][1]
    return a,b,c,d
# stations เป็น dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
 # คืน ลิสต์ของชื่อสถานีที่มีละติจูดน้อยสุด ละติจูดมากสุด ลองจิจูดน้อยสุด และลองจิจูดมากสุด (ต้องคืน 4 ชื่อถึงแม้จะซ้ำ)
def k_nearby_stations(stations, main_station, K):
    [a,b] = [[],[]]
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    for i in stations:
        lat2 = stations[i]['lat']
        long2 = stations[i]['long']
        a.append([distance(lat1, long1, lat2, long2),i])
    a = sorted([[i[0],i[1]] for i in a])[1:K+1]
    for i in range(K):
        b.append(a[i][1])
    return b
# stations เป็น dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
 # main_station เก็บชื่อสถานีที่มีใน stations และ K เป็นจำนวนเต็มบวก
 # คืนลิสต์ของชื่อสถานีที่อยู่ใกล้กับสถานี main_station ที่สุด เป็นจำนวน K สถานี
 # ให้เรียงจากซ้ายไปขวาตามสถานีที่อยู่ใกล้สุดไปไกลขึ้น
 # ในกรณีที่มีระยะเท่ากัน ให้เลือกสถานีที่มีชื่อมาก่อนตามลำดับในพจนานุกรม ในกรณีที่มีไม่ถึง K สถานี ก็คืนเท่าที่ม
def average_temp(stations, names):
    a = []
    b = 0
    for i in names:
        a.append(stations[i.upper()]['temp'])
    for i in a:
        b = b + i
    b = b/len(a)

 # stations เป็น dict เก็บข้อมูลพิกัดและอุณหภูมิของสถานีต่าง ๆ ในรูปแบบที่อธิบายมาก่อนนี้
 # names เป็นลิสต์ที่เก็บชื่อสถานีต่าง ๆ ที่มีใน stations โดยที่ names มีอย่างน้อยหนึ่งชื่อ
 # คืน อุณหภูมิเฉลี่ยของสถานีต่าง ๆ ที่มีชื่อเก็บใน names
    return b
# --------------------------------------------------
# 6330547421 (30) 363 (2021-03-29 16:30)

def approx_match(stations, name):
    n = ''
    for i in name.upper() :
        if 'A' <= i <= 'Z' :
            n += i
    a = []
    for c in stations.keys() :
        if n in c :
            a += [c]
    return a
def top_k_min_temp_stations(stations, K):
    a = sorted(stations[c]['temp'] for c in stations.keys())
    t = []
    for i in a :
        if not ( i in t ) :
            t += [i]
    aa = []
    for i in t :
        for c in sorted(stations.keys()) :
            if stations[c]['temp'] == i :
                aa += [c]
    ans = aa[:K]
    return ans
def top_k_max_temp_stations(stations, K):
    a = sorted((stations[c]['temp'] for c in stations.keys()),reverse=True)
    t = []
    for i in a :
        if not ( i in t ) :
            t += [i]
    aa = []
    for i in t :
        for c in sorted(stations.keys()) :
            if stations[c]['temp'] == i :
                aa += [c]
    ans = aa[:K]
    return ans
def peak_stations(stations):
    ans = []
    la = []
    lo = []
    for c in stations.keys() :
        for i in [stations[c]['lat']] :
            la += [i]
        for o in [stations[c]['long']] :
            lo += [o]
    minla = min(la)
    maxla = max(la)
    minlo = min(lo)
    maxlo = max(lo)
    for c in sorted(stations.keys()) :
        if stations[c]['lat'] == minla :
            ans += [c]
            break
    for c in sorted(stations.keys()) :
        if stations[c]['lat'] == maxla :
            ans += [c]
            break
    for c in sorted(stations.keys()) :
        if stations[c]['long'] == minlo :
            ans += [c]
            break
    for c in sorted(stations.keys()) :
        if stations[c]['long'] == maxlo :
            ans += [c]
            break
    return ans
def k_nearby_stations(stations, main_station, K):
    d = []
    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    S = stations.keys() - [main_station]
    for c in S :
        lat2 = stations[c]['lat']
        long2 = stations[c]['long']
        d += [[distance(lat1, long1, lat2, long2),c]]
    dd = sorted(d)
    a = [i[1] for i in dd[:K] ]
    return a
def average_temp(stations, names):
    s = 0
    for i in names :
        s += stations[i]['temp']
    ss = s / len(names)
    return ss

# --------------------------------------------------
# 6330548021 (30) 364 (2021-03-29 16:59)

def approx_match(stations, name):
    All_stations = []
    keys_stations = list(stations.keys())
    name_new = ''.join(name.split()).upper()
    for station in keys_stations:
        if name_new in station.replace(' ','').upper():
            All_stations.append(station)
    return All_stations
def top_k_min_temp_stations(stations, K):
    station_temp = sorted([[s[1]['temp'],s[0]] for s in stations.items()])
    station_min = [s[1] for s in station_temp][:K]
    return station_min
def top_k_max_temp_stations(stations, K):
    station_temp = sorted([[-s[1]['temp'],s[0]] for s in stations.items()])
    station_max = [s[1] for s in station_temp][:K]
    return station_max
def peak_stations(stations):
    station_lat = sorted([[s[1]['lat'],s[0]] for s in stations.items()])
    station_long = sorted([[s[1]['long'],s[0]] for s in stations.items()])
    peak = [station_lat[0][1],station_lat[-1][1],station_long[0][1],station_long[-1][1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    main_lat = stations[main_station]['lat']
    main_long = stations[main_station]['long']
    station_distance = sorted([[distance(main_lat,main_long,s[1]['lat'],s[1]['long']),s[0]] for s in stations.items()])
    near_station = [s[1] for s in station_distance][1:K+1]
    return near_station
def average_temp(stations, names):
    avg_temp = sum([stations[s]['temp'] for s in names])/len(names)
    return avg_temp

# --------------------------------------------------
# 6330549721 (25.98) 365 (2021-03-25 14:19)

def approx_match(stations, name):
    if len(stations) <=0:
        return []
    return [i for i in stations if name.lower() in i.lower()]
def top_k_min_temp_stations(stations, K):
    if len(stations) <=0:
        return []
    sortedTemp = sorted(stations.items(), key=lambda e: e[1]["temp"])
    KTemps = []
    ReturnList = []
    for i in range(K):
        if i >= len(sortedTemp):
            break
        temp = sortedTemp[i][1]["temp"]
        if temp not in KTemps:
            KTemps.append(sortedTemp[i][1]["temp"])
    SortedAlpha = []
    for i in KTemps:
        StationList = []
        for j in sortedTemp:
            if j[1]["temp"] == i:
                StationList.append(j[0])
        SortedStationList = sorted(StationList)
        for j in SortedStationList:
            if len(SortedAlpha) == K:
                break
            SortedAlpha.append(j)
    return SortedAlpha
def top_k_max_temp_stations(stations, K):
    if len(stations) <=0:
        return []
    sortedTemp = sorted(stations.items(), key=lambda e: e[1]["temp"],reverse=True)
    KTemps = []
    ReturnList = []
    for i in range(K):
        if i >= len(sortedTemp):
            break
        temp = sortedTemp[i][1]["temp"]
        if temp not in KTemps:
            KTemps.append(sortedTemp[i][1]["temp"])
    SortedAlpha = []
    for i in KTemps:
        StationList = []
        for j in sortedTemp:
            if j[1]["temp"] == i:
                StationList.append(j[0])
        SortedStationList = sorted(StationList)
        for j in SortedStationList:
            if len(SortedAlpha) == K:
                break
            SortedAlpha.append(j)
    return SortedAlpha
def peak_stations(stations):
    if len(stations) <=0:
        return []
    laminLs = sorted(stations.items(), key=lambda e: e[1]["lat"])
    lamaxLs = sorted(stations.items(), key=lambda e: e[1]["lat"],reverse=True)
    longminLs = sorted(stations.items(), key=lambda e: e[1]["long"])
    longmaxLs = sorted(stations.items(), key=lambda e: e[1]["long"],reverse=True)
    return [laminLs[0][0],lamaxLs[0][0],longminLs[0][0],longmaxLs[0][0]]
def k_nearby_stations(stations, main_station, K):

    filteredStation = stations.copy()
    #Delete station
    MainStations = ""
    for i in stations:
        if i.lower() == main_station.lower():
            MainStations = i

    if MainStations == "":
        return []

    del filteredStation[MainStations]
    if len(filteredStation) <=0:
        return []

    for i in filteredStation:
        distances = distance(stations[MainStations]["lat"], stations[MainStations]["long"], filteredStation[i]["lat"],  filteredStation[i]["long"])
        filteredStation[i]["distance"] = distances

    sortedDistance = sorted(filteredStation.items(), key=lambda e: e[1]["distance"])
    KDistances = []
    ReturnList = []
    for i in range(K):
        if i >= len(sortedDistance):
            break
        Distance = sortedDistance[i][1]["distance"]
        if Distance not in KDistances:
            KDistances.append(sortedDistance[i][1]["distance"])
    SortedAlpha = []
    for i in KDistances:
        StationList = []
        for j in sortedDistance:
            if j[1]["distance"] == i:
                StationList.append(j[0])
        SortedStationList = sorted(StationList)
        for j in SortedStationList:
            if len(SortedAlpha) == K:
                break
            SortedAlpha.append(j)
    return SortedAlpha
def average_temp(stations, names):
    if len(names) <=0:
        return []
    sumTemp = 0
    for i in names:
        sumTemp += float(stations[i]["temp"])
    return sumTemp/len(names)

# --------------------------------------------------
# 6330550221 (30) 366 (2021-03-29 19:25)

def approx_match(stations, name):
    d = ''
    for e in name:
        if 'A' <= e.upper() <= 'Z':
            d += e.upper()
    v = []
    for key in stations:
        if d in key.upper():
            v += [key]
    return v
def top_k_min_temp_stations(stations, K):
    x = []
    for key in stations:
        x += [[stations[key]['temp'],key]]
    x.sort()
    j = []
    for i in range(K):
        if i <= len(x)-1:
            j += [x[i]]
    d = []
    for i in range(len(j)):
        d += [j[i][1]]
    return d
def top_k_max_temp_stations(stations, K):
    x = []
    for key in stations:
        x += [[-stations[key]['temp'],key]]
    x.sort()
    j = []
    for i in range(K):
        if i <= len(x)-1:
            j += [x[i]]
    d = []
    for i in range(len(j)):
        d += [j[i][1]]
    return d
def peak_stations(stations):
    x = []
    for key in stations:
        x += [[stations[key]['lat'],key]]
    x.sort()
    min_lat = x[0]
    max_lat = x[-1]
    y = []
    for key in stations:
        y += [[stations[key]['long'],key]]
    y.sort()
    min_long = y[0]
    max_long = y[-1]
    g = [min_lat[1],max_lat[1],min_long[1],max_long[1]]
    return g
def k_nearby_stations(stations, main_station, K):
    latt_1 = []
    for key in stations:
        latt_1 += [[str(stations[key]['lat']),key]]
    longg_1 = []
    for key in stations:
        longg_1 += [[str(stations[key]['long']),key]]
    latt_2 = stations[main_station]['lat']
    longg_2 = stations[main_station]['long']
    j = []
    for i in range(len(latt_1)):
        w = distance(float(latt_1[i][0]),float(longg_1[i][0]),float(latt_2),float(longg_2))
        j += [[w,latt_1[i][1]]]
    t = sorted(j)
    p = []
    for i in range(K+1):
        if i <= len(t)-1:
            p += [(t[i])]
    yy = p[1:]
    uu = sorted(yy)
    ss = []
    for i in range(len(uu)):
       ss += [uu[i][1]]
    return ss
def average_temp(stations, names):
    a = []
    for i in range(len(names)):
        a += [(stations[names[i]]['temp'])]
    b = 0
    for i in range(len(a)):
        b += a[i]
    t = b/len(a)
    return t
# --------------------------------------------------
# 6330551921 (27.66) 367 (2021-03-25 20:57)

def approx_match(stations, name):
    names = name.lower().split()
    c=[]
    check=[]
    for i in stations:
        for e in names :
            if e in i.lower() and i.lower() not in check :
                    c.append(i)
                    check.append(i.lower())
    return c
def top_k_min_temp_stations(stations, K):
   x=sorted([[float(stations[i]['temp']),i] for i in stations])

   return [x[:K][i][1] for i in range(len(x[:K]))]
def top_k_max_temp_stations(stations, K):
    x=sorted([[-float(stations[i]['temp']),i] for i in stations])
    return [x[:K][i][1] for i in range(len(x[:K]))]
def peak_stations(stations):
    lat = sorted([[stations[i]['lat'],i] for i in stations])
    lon = sorted([[stations[i]['long'],i] for i in stations])
    return [lat[0][1],lat[-1][1],lon[0][1],lon[-1][1]]
def k_nearby_stations(stations, main_station, K):
    mainsta_info = [stations[main_station]['lat'],stations[main_station]['long']]
    all_distance=['']
    for  i in stations:
        if i!= main_station:
            all_distance.append([distance(mainsta_info[0],mainsta_info[1],stations[i]['lat'],stations[i]['long']),i])
    all_distance = sorted(all_distance[1:])
    return [all_distance[:K][i][1] for i in range(len(all_distance[:K]))]
def average_temp(stations, names):
    x=[]
    for e in names:
        x.append(float(stations[e]['temp']))
    return sum(x)/len(x)



# --------------------------------------------------
# 6330552521 (28.74) 368 (2021-03-29 22:39)

def approx_match(stations, name):
    ls = list(stations)
    l_s = []
    for st in ls:
        lss = []
        state = ''
        for x in st:
            if x.isalpha() == True:
                state += x
            else:
                pass
        lss.append(state)
        lss.append(st)
        l_s.append(lss)
    key = ''.join([x.upper() for x in name if x.isalpha() == True])
    aprx = [state[1] for state in l_s if key in state[0]]
    return aprx
def top_k_min_temp_stations(stations, K):
    l_s = list(stations)
    sat = [[stations[x]['temp'], x] for x in l_s]
    sat = sorted(sat)
    tkmits = [x[1] for x in sat][:K]
    return tkmits
def top_k_max_temp_stations(stations, K):
    l_s = list(stations)
    sat = [[stations[x]['temp'], x] for x in l_s]
    sat = sorted(sat, reverse=True)
    tkmats = [x[1] for x in sat][:K]
    return tkmats
def peak_stations(stations):
    l_s = list(stations)
    max_lat = max([[stations[x]['lat'], x] for x in l_s])
    min_lat = min([[stations[x]['lat'], x] for x in l_s])
    max_long = max([[stations[x]['long'], x] for x in l_s])
    min_long = min([[stations[x]['long'], x] for x in l_s])
    pks = [min_lat[1], max_lat[1], min_long[1], max_long[1]]
    return pks
def k_nearby_stations(stations, main_station, K):
    l_s = list(stations)
    la1 = stations[main_station]['lat']
    lo1 = stations[main_station]['long']
    slalo = [ [ distance(la1, lo1, stations[x]['lat'], stations[x]['long']), x ] for x in l_s]
    knsp = sorted(slalo)[ 1 : K + 1 ]
    kns = [ y[1] for y in knsp ]
    return kns
def average_temp(stations, names):
    temp = [stations[st]['temp'] for st in names]
    av_temp = ( ( round( sum( temp ) , 2 ) ) / ( len( temp ) ) )
    return av_temp

# --------------------------------------------------
# 6330553121 (30) 369 (2021-03-29 22:28)

def approx_match(stations, name):
    new_name = ''
    for a in name:
        if a != ' ':
            new_name += a.upper()

    ori_modi = []

    for st in stations :
        new_st = ''
        for ch in st :
            if ch != ' ':
                new_st += ch.upper()
        ori_modi.append([st,new_st])

    list_of_valid_station = []
    for pair_station in ori_modi :
        if new_name in pair_station[1] :
            list_of_valid_station.append(pair_station[0])

    return list_of_valid_station
def top_k_min_temp_stations(stations, K):
    temp_station = [[stations[s]['temp'],s] for s in stations]
    temp_station.sort()
    min_k_temp_station = temp_station[:K]
    min_station = [e[1] for e in min_k_temp_station]
    return min_station
def top_k_max_temp_stations(stations, K):
    temp_station = [[-stations[s]['temp'],s] for s in stations]
    temp_station.sort()
    max_k_temp_station = temp_station[:K]
    max_station = [e[1] for e in max_k_temp_station]
    return max_station
def peak_stations(stations):
    lat_s = sorted([[stations[s]['lat'],s] for s in stations])
    long_s = sorted([[stations[s]['long'],s] for s in stations])
    peak_list = [lat_s[0][1],lat_s[-1][1],long_s[0][1],long_s[-1][1]]
    return peak_list
def k_nearby_stations(stations, main_station, K):
    for s in stations :
        if s == main_station :
            lat_main = stations[s]['lat']
            long_main = stations[s]['long']
            break
    d_station = []
    for e in stations :
        d_station.append([distance(lat_main,long_main,stations[e]['lat'],stations[e]['long']),e])
    sort_d_station = sorted(d_station)
    sta = []
    for l in sort_d_station :
        sta.append(l[1])
    show = sta[1:K+1:]
    return show
def average_temp(stations, names):
    c = 0 ; sum_temp = 0
    for s in names :
        if s in stations :
            sum_temp += stations[s]['temp']
            c += 1
    return sum_temp/c
# --------------------------------------------------
# 6330554821 (30) 370 (2021-03-27 00:51)

def approx_match(stations, name):

    base = []
    for k in stations:
        base.append(k)
    new = []
    for i in range(len(base)):
        s = ''
        for e in range(len(base[i])):
            if base[i][e] == ' ':
                s += ''
            else:
                s += base[i][e]
        new.append(s.lower())
    name1 = name.lower()
    ss = ''
    for i in range(len(name1)):
        if name1[i] == ' ':
            ss += ''
        else:
            ss += name1[i]
    out = []
    for i in range(len(new)):
        if ss in new[i]:
            out.append(base[i])
    return out
def top_k_min_temp_stations(stations, K):

    new = []
    for e in stations:
        a = stations[e]['temp']
        new.append([a,e])
    new.sort()
    out = new[:int(K):]
    re = []
    for i in range(len(out)):
        re.append(out[i][1])
    return re
def top_k_max_temp_stations(stations, K):

    new = []
    for e in stations:
        a = -(stations[e]['temp'])
        new.append([a,e])
    new.sort()
    out = new[:int(K):]
    re1 = []
    for i in range(len(out)):
        re1.append(out[i][1])
    return re1
def peak_stations(stations):

    lat_low = []
    lat_high = []
    long_low = []
    long_high = []
    for k in stations:
        a = stations[k]['lat']
        b = -a
        c = stations[k]['long']
        d = -c
        lat_low.append([a,k])
        lat_high.append([b,k])
        long_low.append([c,k])
        long_high.append([d,k])
    lat_low.sort()
    lat_high.sort()
    long_low.sort()
    long_high.sort()
    out1 = [lat_low[0][1],lat_high[0][1],long_low[0][1],long_high[0][1]]
    return out1
def k_nearby_stations(stations, main_station, K):

    lat1 = stations[main_station]['lat']
    long1 = stations[main_station]['long']
    lat2 = []
    long2 = []
    for k in stations:
        if k != main_station:
            a = stations[k]['lat']
            b = stations[k]['long']
            lat2.append([a,k])
            long2.append([b,k])
    new = []
    for i in range(len(lat2)):
        c = lat2[i][0]
        d = long2[i][0]
        out = distance(lat1,long1,c,d)
        new.append([out,lat2[i][1]])
    new.sort()
    if len(new) >= K:
        q = new[:int(K):]
    else:
        q = new
    ans = []
    for i in range(len(q)):
        ans.append(q[i][1])
    return ans
def average_temp(stations, names):

    summ = 0
    for i in range(len(names)):
        a = stations[names[i]]['temp']
        summ += a
    cal = summ/len(names)
    return cal

# --------------------------------------------------
# 6330555421 (28.74) 371 (2021-03-28 14:22)

def approx_match(stations, name):
    name = name.upper()
    name1 = ''
    station = []
    for keys in stations :
        station.append(keys)
    for ch in name :
        if ch != ' ':
            name1 += ch
    lst = []
    for i in range(len(station)) :
        if name1 in station[i] :
            lst.append(station[i])
    return lst
def top_k_min_temp_stations(stations, K):
    temp = []
    station_temp = []
    for keys in stations :
        station_temp.append([stations[keys]['temp'],keys])
    station_temp.sort()
    mintemp_station = []
    if K > len(station_temp) :
        for k in range(len(station_temp)) :
            mintemp_station.append(station_temp[k][1])
    else :
        for i in range(0,K) :
            mintemp_station.append(station_temp[i][1])

    return mintemp_station
def top_k_max_temp_stations(stations, K):
    temp = []
    station_temp = []
    for keys in stations :
        station_temp.append([stations[keys]['temp'],keys])
    station_temp = sorted(station_temp, reverse = True)
    maxtemp_station = []
    if K > len(station_temp) :
        for k in range(len(station_temp)) :
            maxtemp_station.append(station_temp[k][1])
    else :
        for i in range(0,K) :
            maxtemp_station.append(station_temp[i][1])

    return maxtemp_station
def peak_stations(stations):
    peak = []
    long = []
    lat = []
    for keys in stations :
        long.append([stations[keys]['long'],keys])
        lat.append([stations[keys]['lat'],keys])
    long.sort()
    lat.sort()
    peak.append(lat[0][1])
    peak.append(lat[-1][1])
    peak.append(long[0][1])
    peak.append(long[-1][1])
    return peak
def k_nearby_stations(stations, main_station, K):
    main_station = main_station.upper()
    distance1 = []
    lst_lat_long = []
    for keys in stations :
        lst_lat_long.append([keys,stations[keys]['lat'],stations[keys]['long']])
    for i in range(len(lst_lat_long)) :
        distance1.append([(distance(float(stations[main_station]['lat']),float(stations[main_station]['long']), float(lst_lat_long[i][1]), float(lst_lat_long[i][2]))),lst_lat_long[i][0]])
    distance1.sort()
    nearby = distance1[1:K+1]
    real_nearby = []
    for j in range(len(nearby)) :
        real_nearby.append(nearby[j][1])
    return real_nearby
def average_temp(stations, names):
    sum_temp = 0
    for i in range(len(names)) :
        sum_temp += float(stations[names[i]]['temp'])
    average = sum_temp/len(names)
    return average



# --------------------------------------------------
# 6330556021 (30) 372 (2021-03-29 20:36)

def approx_match(stations, name):
    match = []
    name = name.replace(" ","")
    for i in stations.keys():
        if name.upper() in i.upper().replace(" ",""):
            match.append(i.upper())
    return (match)
def top_k_min_temp_stations(stations, K):
    all_temp_station = sorted([[stations[i]["temp"], i] for i in stations])
    n = 0
    z = 1
    for i in range(1, len(all_temp_station)):
        if all_temp_station[i-1][0] == all_temp_station[i][0]:
            z += 1
        else:
            all_temp_station[n:z] = sorted(all_temp_station[n:z])
            n = z
            z += 1
        all_temp_station[n:z] = sorted(all_temp_station[n:z])
    if K > len(stations.keys()):
        K = len(stations.keys())
    all_temp_station = all_temp_station[0:K]
    min_temp_station = [j[1] for j in all_temp_station]
    return min_temp_station
def top_k_max_temp_stations(stations, K):
    all_temp_station = sorted([[stations[i]["temp"], i] for i in stations], reverse = True)
    n = 0
    z = 1
    for i in range(1, len(all_temp_station)):
        if all_temp_station[i-1][0] == all_temp_station[i][0]:
            z += 1
        else:
            all_temp_station[n:z] = sorted(all_temp_station[n:z])
            n = z
            z += 1
        all_temp_station[n:z] = sorted(all_temp_station[n:z])
    if K > len(stations.keys()):
        K = len(stations.keys())
    all_temp_station = all_temp_station[0:K]
    max_temp_station = [j[1] for j in all_temp_station]
    return max_temp_station
def peak_stations(stations):
    lat_station = sorted([[stations[i]["lat"], i] for i in stations])
    long_station = sorted([[stations[i]["long"], i] for i in stations])
    show = []
    show.append(lat_station[0][1])
    show.append(lat_station[-1][1])
    show.append(long_station[0][1])
    show.append(long_station[-1][1])
    return show
def k_nearby_stations(stations, main_station, K):
    mlat = stations[main_station]["lat"]
    mlong = stations[main_station]["long"]
    distance_station = sorted([[distance(mlat, mlong, stations[i]["lat"], stations[i]["long"]), i] for i in stations])
    n = 0
    z = 1
    for i in range(1, len(distance_station)):
        if distance_station[i-1][0] == distance_station[i][0]:
            z += 1
        else:
            distance_station[n:z] = sorted(distance_station[n:z])
            n = z
            z += 1
        distance_station[n:z] = sorted(distance_station[n:z])
    if K > len(stations.keys()):
            K = len(stations.keys())
    nearby = [i[1] for i in distance_station[1:K+1]]
    return nearby
def average_temp(stations, names):
    avg_temp = sum([stations[i]["temp"] for i in names])/len(names)
    return avg_temp
# --------------------------------------------------
# 6330557721 (30) 373 (2021-03-29 21:14)

def approx_match(stations, name):
    Lname = name.upper()
    Localz = []
    for key in stations:
        if Lname in key.upper().replace(' ',''):
            Localz.append(key.upper())
    a = ''
    for i in range(len(Lname)):
        if Lname[i] != ' ':
            a+=Lname[i]

    for key in stations:
        if a in key.upper().replace(' ',''):
            if key.upper() not in Localz:
                Localz.append(key)
    return Localz
def top_k_min_temp_stations(stations, K):
    TemMi1 = []
    for key in stations:
        m,n = stations[key]['temp'],key
        TemMi1.append([m,n])
    TemMi1.sort()
    a =[]
    b = []
    for i in range(len(TemMi1)-1):
        if TemMi1[i][0] != TemMi1[i+1][0]:
            b.append(TemMi1[i])
            b.sort()
            a +=b
            b = []
        else:
            b.append(TemMi1[i])
    TemMi2 = []
    for i in range(len(a)):
        TemMi2.append(a[i][1])

    return TemMi2[:K]
def top_k_max_temp_stations(stations, K):
    TemMi1 = []
    for key in stations:
        m,n = stations[key]['temp'],key
        TemMi1.append([m,n])
    TemMi1.sort(reverse=True)
    a =[]
    b = []
    for i in range(len(TemMi1)-1):
        if TemMi1[i][0] != TemMi1[i+1][0]:
            b.append(TemMi1[i])
            b.sort()
            a +=b
            b = []
        else:
            b.append(TemMi1[i])

    TemMi2 = []
    for i in range(len(a)):
        TemMi2.append(a[i][1])

    return TemMi2[:K]
def peak_stations(stations):
    Lat = []
    Long =[]
    for key in stations:
        m,n = stations[key]['lat'],key
        Lat.append([m,n])
        k,o = stations[key]['long'],key
        Long.append([k,o])
    Lat.sort()
    Long.sort()
    lai = Lat[0][1]
    laa = Lat[-1][1]
    loi = Long[0][1]
    loa = Long[-1][1]
    LatLong = [lai,laa,loi,loa]
    return LatLong
def k_nearby_stations(stations, main_station, K):
    D = []
    la1 = stations[main_station]['lat']
    la2 = stations[main_station]['long']
    for key in stations:
        D.append([(distance(la1,la2,stations[key]['lat'],stations[key]['long'])),key])
    D.sort()
    N = []
    for i in range(len(D)):
        N.append(D[i][1])
    return N[1:K+1]
def average_temp(stations, names):
    Sum = 0
    for key in stations:
        for i in range(len(names)):
            if names[i] == key:
                Sum += (stations[key]['temp'])
    Pon = Sum/len(names)
    return Pon

# --------------------------------------------------
# 6330558321 (0) 374 (2021-03-29 11:45)

# 6330559021 (28.02) 375 (2021-03-28 21:38)

def approx_match(stations, name) :

    name = "".join([e for e in name.upper().strip() if "A" <= e <= "Z"])
    return [e for e in stations if name in "".join(e.split())]
def top_k_min_temp_stations(stations, K):


    forreturn =[]
    m = {}
    for e in stations :
        m[stations[e]["temp"]] = e
    x = sorted([stations[e]["temp"]for e in stations])
    for i in range(len(x)) :
        if x[i] == x[(i+1)%len(x)] :
            if m[x[i]] < m[x[i+1]] : forreturn += [m[x[i]],m[x[i+1]]]
            else : forreturn += [m[x[i+1]],m[x[i]]]
        else : forreturn.append(m[x[i]])
    if len(forreturn) < K:
        return forreturn[:len(forreturn):]
    else :return forreturn[:K:]
def top_k_max_temp_stations(stations, K):
    forreturn =[]
    m = {}
    for e in stations :
        m[stations[e]["temp"]] = e
    x = sorted([stations[e]["temp"]for e in stations],reverse=True)
    for i in range(len(x)) :
        if x[i] == x[(i+1)%len(x)] :
            if m[x[i]] < m[x[i+1]] : forreturn += [m[x[i]],m[x[i+1]]]
            else : forreturn += [m[x[i+1]],m[x[i]]]
        else : forreturn.append(m[x[i]])
    if len(forreturn) < K:
        return forreturn[:len(forreturn):]
    else :return forreturn[:K:]
def peak_stations(stations):

    newlat = {}
    newlong ={}
    for e in stations :
        newlat[stations[e]["lat"]] = e
        newlong[stations[e]["long"]] = e
    lat = sorted([stations[e]["lat"]for e in stations])
    long = sorted([stations[e]["long"]for e in stations])
    return [newlat[lat[0]], newlat[lat[-1]], newlong[long[0]], newlong[long[-1]]]
def k_nearby_stations(stations, main_station, K):

    forreturn = []
    new = {}
    x=[]
    mainlat = stations[main_station]["lat"]
    mainlong = stations[main_station]["long"]
    for e in stations:
        x.append(distance(mainlat, mainlong, stations[e]["lat"], stations[e]["long"]))
        new[distance(mainlat, mainlong, stations[e]["lat"], stations[e]["long"])] = e
    x = sorted(x)
    for i in range(len(x)) :
        if x[i] == x[(i+1)%len(x)] :
            if new[x[i]] < new[x[i+1]] : forreturn += [new[x[i]],new[x[i+1]]]
            else : forreturn += [new[x[i+1]],new[x[i]]]
        else : forreturn.append(new[x[i]])
    if len(forreturn) < K:
        return forreturn[:len(forreturn):]
    else :return forreturn[1:K+1:]
def average_temp(stations, names):


    x=[stations[e]["temp"]for e in names]
    return sum(x)/len(x)


# --------------------------------------------------
# 6330560521 (30) 376 (2021-03-28 23:51)

def approx_match(stations, name):
    name = name.upper().split()
    name = ''.join(name)
    x = []
    for key in stations :
        y = key.split()
        y = ''.join(y)
        if name in y :
            x.append(key)
    #print(x)
    return x
def top_k_min_temp_stations(stations, K):
    Temp = []
    for key in stations :
        x = stations[key]['temp']
        T = []
        T.append(x)
        T.append(key)
        Temp.append(T)
    Temp.sort()
    #print(Temp)
    if K <= len(Temp):
        Temp = Temp[:K]
    min_temp = []
    for e in Temp :
        min_temp.append(e[1])
    #print(min_temp)
    return min_temp
def top_k_max_temp_stations(stations, K):
    Temp = []
    for key in stations :
        x = stations[key]['temp']
        T = []
        T.append(x)
        T.append(key)
        Temp.append(T)
    Temp = sorted(Temp,key=lambda x: x[1])
    Temp = sorted(Temp,key=lambda x: x[0], reverse=True)
    #print(Temp)
    if K <= len(Temp):
        Temp = Temp[:K]
    max_temp = []
    for e in Temp :
        max_temp.append(e[1])
    #print(max_temp)
    return max_temp
def peak_stations(stations):
    latitude = []
    longitude = []
    for key in stations:
        la = []
        lo = []
        x = stations[key]['lat']
        y = stations[key]['long']
        la.append(x)
        la.append(key)
        latitude.append(la)
        lo.append(y)
        lo.append(key)
        longitude.append(lo)
    latitude.sort()
    longitude.sort()
    #print(latitude)
    #print(longitude)
    min_lat = latitude[0][1]
    max_lat = latitude[-1][1]
    min_long = longitude[0][1]
    max_long = longitude[-1][1]
    n = []
    n.append(min_lat)
    n.append(max_lat)
    n.append(min_long)
    n.append(max_long)
    #print(n)
    return n
def k_nearby_stations(stations, main_station, K):
    nearby = []
    all_st = []
    main_st = main_station.upper()
    for key in stations :
        all_st.append(key.upper())
    for key in stations :
        if main_st in all_st :
            lat1 = float(stations[main_st]['lat'])
            long1 = float(stations[main_st]['long'])
            lat2 = float(stations[key]['lat'])
            long2 = float(stations[key]['long'])
            d = distance(lat1, long1, lat2, long2)
            x = []
            x.append(d)
            x.append(key)
            nearby.append(x)
    nearby.sort()
    if K <= len(nearby) :
        nearby = nearby[1:K+1]
    else :
        nearby = nearby[1:]
    nearby_st =[]
    for e in nearby :
        nearby_st.append(e[1])
    #print(nearby_st)
    #print(len(nearby_st))
    return nearby_st
def average_temp(stations, names):
    all_st = []
    sum_t = 0
    k = 0
    for key in stations :
        all_st.append(key)
    for n in names :
        n.upper()
        if n in all_st :
            t = stations[n]['temp']
            sum_t += float(t)
            k += 1
    average_t = sum_t/k
    return average_t
# --------------------------------------------------
# 6330561121 (28.74) 377 (2021-03-25 14:06)

def approx_match(stations, name):
    temlist = []
    for key in stations :
        if name.replace(" ","").lower() in key.lower() : temlist.append(key)
    return temlist
def top_k_min_temp_stations(stations, K):
    tempist = []
    nntempist = []
    for key in stations:
        tempist.append([stations[key]['temp'], key])
    ntempist = sorted(tempist)[:K]
    for i in range(len(ntempist)):
        nntempist.append(ntempist[i][1])
    return nntempist
def top_k_max_temp_stations(stations, K):
    tempist = []
    nntempist = []
    for key in stations:
        tempist.append([stations[key]['temp'], key])
    ntempist = sorted(tempist,reverse = True)[:K]
    for i in range(len(ntempist)):
        nntempist.append(ntempist[i][1])
    return nntempist
def peak_stations(stations):
    a = sorted([stations[key]['lat'],key] for key in stations)[:3]
    b = sorted(([stations[key]['lat'],key] for key in stations), reverse = True)[:3]
    c = sorted([stations[key]['long'],key] for key in stations)[:3]
    d = sorted(([stations[key]['long'],key] for key in stations), reverse = True)[:3]
    peak = [a[0][1],b[0][1],c[0][1],d[0][1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    tempost = []
    nntempost = []
    for key in stations:
        tempost.append([distance(stations[key]['lat'],stations[key]['long'],stations[main_station]['lat'],stations[main_station]['long']),key])
    ntempost = sorted(tempost)[1:K+1]
    for i in range(len(ntempost)):
        nntempost.append(ntempost[i][1])
    return nntempost
def average_temp(stations, names):
    temporarylist = []
    for e in names:
        temporarylist.append(stations[e]['temp'])
    av = sum(temporarylist)/len(temporarylist)
    return av
# --------------------------------------------------
# 6330562821 (30) 378 (2021-03-29 00:14)

def approx_match(stations, name):
    keys = {}
    for layout in stations:
        k = ''.join(e for e in layout if e != ' ')
        keys[layout] = k
    name = ''.join(e.upper() for e in name if e != ' ')
    return [e for e in keys if name in keys[e]]
def top_k_min_temp_stations(stations, K):
    temp = sorted([stations[e]["temp"], e] for e in stations)
    return [temp[i][1].upper() for i in range(min(K, len(temp)))]
def top_k_max_temp_stations(stations, K):
    temp = sorted([-stations[e]["temp"], e] for e in stations)
    return [temp[i][1].upper() for i in range(min(K, len(temp)))]
def peak_stations(stations):
    Lat = sorted([stations[e]["lat"], e] for e in stations)
    Long = sorted([stations[e]["long"], e] for e in stations)
    return [Lat[0][1], Lat[-1][1], Long[0][1], Long[-1][1]]
def k_nearby_stations(stations, main_station, K):
    lat1 = stations[main_station.upper()]["lat"]
    long1 = stations[main_station.upper()]["long"]
    near_by = sorted([distance(lat1, long1, stations[e]["lat"], stations[e]["long"]), e] for e in stations if e != main_station)
    return [near_by[i][1] for i in range (min(K, len(near_by)))]
def average_temp(stations, names):
    keep = [stations[e]["temp"] for e in names]
    return sum(keep)/len(keep)

# --------------------------------------------------
# 6330563421 (30) 379 (2021-03-28 21:06)

def approx_match(stations, name):

    def clean_name(x):
        cname=''
        for k in x.upper():
            if k!=' ':
                cname+=k
        return cname
    approx=[]
    for k in stations:
        if clean_name(name) in clean_name(k):
            approx.append(k)
    return approx
def top_k_min_temp_stations(stations, K):

    temp_list=[]
    for e in stations:
        temp_list.append([stations[e]['temp'],e])
    temp_list_name=[e[1] for e in sorted(temp_list)]
    return temp_list_name[:K]
def top_k_max_temp_stations(stations, K):

    temp_list=[]
    for e in stations:
        temp_list.append([stations[e]['temp'],e])
    temp_list_name=[e[1] for e in sorted([-1*e[0],e[1]] for e in temp_list)]
    return temp_list_name[:K]
def peak_stations(stations):

    lat_list=[]
    long_list=[]
    for e in stations:
        lat_list.append([stations[e]['lat'],e])
        long_list.append([stations[e]['long'],e])
    lat_list.sort()
    long_list.sort()
    return [lat_list[0][1],lat_list[-1][1],long_list[0][1],long_list[-1][1]]
def k_nearby_stations(stations, main_station, K):

    lat_main=stations[main_station]['lat']
    long_main=stations[main_station]['long']
    dis_dict={}
    for e in stations:
        if e!=main_station:
            lat_e=stations[e]['lat']
            long_e=stations[e]['long']
            dis_dict[e]=distance(lat_main,long_main,lat_e,long_e)
    dis_list=[e[1] for e in sorted([dis_dict[e],e] for e in dis_dict)]
    return dis_list[:K]
def average_temp(stations, names):

    temp_sum=0
    for n in names:
        temp_sum+=stations[n]['temp']
    return temp_sum/len(names)

# --------------------------------------------------
# 6330564021 (30) 380 (2021-03-27 18:21)

def approx_match(stations, name):
    newstations = []
    for k in stations:
        if k.find(''.join(name.split()).upper()) != -1:
            newstations.append(k)
    return newstations
def top_k_min_temp_stations(stations, K):
    newtemps = {}
    for k in stations:
        newtemps[k] = stations[k]['temp']
    temps = sorted([[temp[1],temp[0]] for temp in newtemps.items()])[:K]
    return [temp[1] for temp in temps]
def top_k_max_temp_stations(stations, K):
    newtemps = {}
    for k in stations:
        newtemps[k] = stations[k]['temp']
    temps = sorted([[-temp[1],temp[0]] for temp in newtemps.items()])[:K]
    return [temp[1] for temp in temps]
def peak_stations(stations):
    newlongs,newlats = {},{}
    for k in stations:
        newlongs[k] = stations[k]['long']
        newlats[k] = stations[k]['lat']
    lats = sorted([[lat[1],lat[0]] for lat in newlats.items()])
    longs = sorted([[long[1],long[0]] for long in newlongs.items()])
    return [lats[0][1], lats[-1][1], longs[0][1], longs[-1][1]]
def k_nearby_stations(stations, main_station, K):
    dist_sta = {}
    for k in stations:
        dist_sta[k] = distance(stations[k]['lat'], stations[k]['long'], stations[main_station]['lat'], stations[main_station]['long'])
    dists = sorted([[dist[1],dist[0]] for dist in dist_sta.items()])[1:K+1]
    return [dist[1] for dist in dists]
def average_temp(stations, names):
    mean_temp = 0
    for k in names:
        mean_temp += stations[k]['temp']
    return mean_temp/len(names)

# --------------------------------------------------
# 6330565721 (30) 381 (2021-03-29 20:57)

def approx_match(stations, name):
    return [key for key, val in stations.items() if name.upper().replace(" ","") in key.replace(" ","")]
def top_k_min_temp_stations(stations, K):
    a=list(stations.keys())
    b=[]

    for i in range(K):
        mina = min(a,key=lambda e:stations[e]['temp'])
        a.remove(mina)
        b.append(mina)
    mina = min(a,key=lambda e:stations[e]['temp'])
    a.remove(mina)
    while stations[mina]['temp'] == stations[b[-1]]['temp'] and len(a) > 0:
        b.append(mina)
        mina = min(a, key=lambda e: stations[e]['temp'])
        a.remove(mina)
    b.sort()
    b.sort(key=lambda e:stations[e]['temp'])
    return b[:K]
def top_k_max_temp_stations(stations, K):
    a=list(stations.keys())
    b=[]
    for i in range(K):
        mina = min(a,key=lambda e:-stations[e]['temp'])
        a.remove(mina)
        b.append(mina)
    mina = min(a,key=lambda e:-stations[e]['temp'])
    a.remove(mina)

    while stations[mina]['temp'] == -stations[b[-1]]['temp'] and len(a) > 0:
        b.append(mina)
        mina = min(a, key=lambda e: -stations[e]['temp'])
        a.remove(mina)

    b.sort(key=lambda e:-stations[e]['temp'])
    return b[:K]
def peak_stations(stations):
    a = sorted(stations,key=lambda x:(stations[x]['lat'])) ; b = sorted(stations,key=lambda x:(stations[x]['long']))
    return [a[0],a[-1],b[0],b[-1]]
def k_nearby_stations(stations, main_station, K):
    K=K+1
    a=stations[main_station]['lat'] ;b=stations[main_station]['long']
    x=list(stations.keys()) ; y=[]

    for i in range(K):
        minx = min(x,key=lambda e:distance(a,b,stations[e]['lat'],stations[e]['long']))
        x.remove(minx)
        y.append(minx)
    minx = min(x,key=lambda e:distance(a,b,stations[e]['lat'],stations[e]['long']))
    x.remove(minx)
    while distance(a,b,stations[minx]['lat'],stations[minx]['long']) == distance(a,b,stations[y[-1]]['lat'],stations[y[-1]]['long']) and len(x) > 0:
        y.append(minl)
        minx = min(x, key=lambda e: distance(a,b,stations[e]['lat'],stations[e]['long']))
        x.remove(minl)
    y.sort()
    y.sort(key=lambda e:distance(a,b,stations[e]['lat'],stations[e]['long']))
    return y[1:K+1]
def average_temp(stations, names):
    a = 0
    for i in names :
        a += stations[i]['temp']
    return (a/len(names))



# --------------------------------------------------
# 6330566321 (30) 382 (2021-03-29 02:02)

def approx_match(stations, name):
    name = remove_space(name.lower())
    sKeys = list(stations.keys())
    matches = []

    for key in sKeys:
        if name in remove_space(key.lower()):
            matches.append(key)

    return matches
def top_k_min_temp_stations(stations, K):
    minStations = []

    for key, value in stations.items():
        if len(minStations) < K:
            minStations.append(key)
        else:
            minStations.sort(reverse=True)
            minStations.sort(key=lambda e: -stations[e]['temp'])
            if value['temp'] < stations[minStations[0]]['temp']:
                minStations[0] = key
            elif value['temp'] == stations[minStations[0]]['temp']:
                if key < minStations[0]:
                    minStations[0] = key
    minStations.sort()
    minStations.sort(key=lambda e: stations[e]['temp'])

    return minStations
def top_k_max_temp_stations(stations, K):
    maxStations = []

    for key, value in stations.items():
        if len(maxStations) < K:
            maxStations.append(key)
        else:
            maxStations.sort(reverse=True)
            maxStations.sort(key=lambda e: stations[e]['temp'])
            if value['temp'] > stations[maxStations[0]]['temp']:
                maxStations[0] = key
            elif value['temp'] == stations[maxStations[0]]['temp']:
                if key < maxStations[0]:
                    maxStations[0] = key
    maxStations.sort()
    maxStations.sort(key=lambda e: -stations[e]['temp'])

    return maxStations
def peak_stations(stations):
    t = 0
    for station, value in stations.items():
        lat = value['lat']
        long = value['long']

        if t == 0:
            minLat = lat
            minLatStation = station
            maxLat = lat
            maxLatStation = station
            minLong = long
            minLongStation = station
            maxLong = long
            maxLongStation = station
            t = 1
        else:
            if lat < minLat:
                minLat = lat
                minLatStation = station
            elif lat == minLat and station < minLatStation:
                minLatStation = station

            if lat > maxLat:
                maxLat = lat
                maxLatStation = station
            elif lat == maxLat and station < maxLatStation:
                maxLatStation = station

            if long < minLong:
                minLong = long
                minLongStation = station
            elif long == minLong and station < minLongStation:
                minLongStation = station

            if long > maxLong:
                maxLong = long
                maxLongStation = station
            elif long == maxLong and station < maxLongStation:
                maxLongStation = station

    return [minLatStation, maxLatStation, minLongStation, maxLongStation]
def k_nearby_stations(stations, main_station, K):
    mainLat = stations[main_station]['lat']
    mainLong = stations[main_station]['long']
    nearbyStations = []

    for station, value in stations.items():
        lat = value['lat']
        long = value['long']
        value['dis'] = distance(mainLat, mainLong, lat, long)
        dis = value['dis']
        if station != main_station:
            if len(nearbyStations) < K:
                nearbyStations.append(station)
            else:
                nearbyStations.sort(reverse=True)
                nearbyStations.sort(key=lambda e: -stations[e]['dis'])
                if dis < stations[nearbyStations[0]]['dis']:
                    nearbyStations[0] = station
                elif dis == stations[nearbyStations[0]]['dis']:
                    if station < nearbyStations[0]:
                        nearbyStations[0] = station
        nearbyStations.sort()
        nearbyStations.sort(key=lambda e: stations[e]['dis'])

    return nearbyStations
def average_temp(stations, names):
    return sum([stations[name]['temp'] for name in names]) / len(names)


# --------------------------------------------------
def remove_space(s):
    ans = ''
    for c in s:
        if c != ' ':
            ans += c
    return ans
# 6330567021 (30) 383 (2021-03-27 11:58)

def approx_match(stations, name):
    countries = []
    small = [[more_func(item),item] for item in stations]
    d_of_small = {}
    for i in small:
        d_of_small[i[0]] = i[1]
    name = name.strip()
    name = name.lower().split()
    full_name = ''
    for i in name:full_name += i
    for i in d_of_small:
        if full_name in i:countries.append(d_of_small[i])
    return countries
def top_k_min_temp_stations(stations, K):
    stations_temp = {}
    only_temp = []
    for i in stations:stations_temp[i] = stations[i]['temp']
    only_temp_name = [i[1] for i in sorted([[item[1],item[0]] for item in stations_temp.items()])]
    if len(only_temp_name) >= K:return only_temp_name[:K]
    else:return only_temp_name
def top_k_max_temp_stations(stations, K):
    stations_temp = {}
    only_temp = []
    for i in stations:stations_temp[i] = stations[i]['temp']
    only_temp_name = [i[1] for i in sorted([[-item[1],item[0]] for item in stations_temp.items()])]
    if len(only_temp_name) >= K:return only_temp_name[:K]
    else:return only_temp_name
def peak_stations(stations):
    lat = []
    long = []
    for data in stations:
        lat.append([stations[data]['lat'],data])
        long.append([stations[data]['long'],data])
    lat.sort()
    long.sort()
    l_lat = lat[0]
    m_lat = lat[-1]
    l_long = long[0]
    m_long = long[-1]
    peak = [l_lat[1],m_lat[1],l_long[1],m_long[1]]
    return peak
def k_nearby_stations(stations, main_station, K):
    small = [[item.lower(),item] for item in stations]
    d_of_small = {}
    for i in small:
        d_of_small[i[0]] = i[1]
    main_station = main_station.lower()
    lat_0 =stations[d_of_small[main_station]]['lat']
    long_0 =stations[d_of_small[main_station]]['long']
    dis = {}
    for i in stations:
        lat = stations[i]['lat']
        long = stations[i]['long']
        dis[i] = distance(lat_0,long_0,lat,long)
    name = [i[1] for i in sorted([[item[1],item[0]] for item in dis.items()])[1::]]
    if len(name) >= K:return name[:K]
    else:return name
def average_temp(stations, names):
    time=0
    temp=0
    for radio in names:
        if radio in stations:
            temp+=float(stations[radio]['temp'])
            time+=1
    avg = temp/time
    return avg
# --------------------------------------------------
def more_func(stations):
    stations = stations.split()
    last = ''
    for i in stations:
        last += i.lower()
    return last
# 6330568621 (30) 384 (2021-03-28 19:39)

def approx_match(stations, name):
    name = "".join(name.split()).upper()
    return [province for province in stations if name in province.upper()]
def top_k_min_temp_stations(stations, K):
    return [
        key for key, val in sorted(stations.items(), key=lambda x: x[1]["temp"])[:K]
    ]
def top_k_max_temp_stations(stations, K):
    return [
        key
        for key, val in sorted(
            stations.items(), key=lambda x: x[1]["temp"], reverse=True
        )[:K]
    ]
def peak_stations(stations):
    return [
        min(stations.items(), key=lambda x: x[1]["lat"])[0],
        max(stations.items(), key=lambda x: x[1]["lat"])[0],
        min(stations.items(), key=lambda x: x[1]["long"])[0],
        max(stations.items(), key=lambda x: x[1]["long"])[0],
    ]
def k_nearby_stations(stations, main_station, K):
    pos_lat, pos_long = stations[main_station]["lat"], stations[main_station]["long"]
    return [
        key
        for key, val in sorted(
            stations.items(),
            key=lambda x: (distance(pos_lat, pos_long, x[1]["lat"], x[1]["long"])),
        )[1 : K + 1]
    ]
def average_temp(stations, names):
    return sum([stations[name]["temp"] for name in names]) / len(names)


# --------------------------------------------------
# 6330569221 (24) 385 (2021-03-29 20:31)

def approx_match(stations, name):
    a=[]
    ans=name.split()
    ans = ''.join(ans)
    for i in stations:
        if ans.lower() in i.lower():
            a.append(i)
    return a
def top_k_min_temp_stations(stations, K):
    a=[]
    for i in stations:
        r = stations[i]['temp']
        a.append([r,i])
    a.sort()
    mi = a[:K]
    p = []
    for i in range(len(mi)):
        y=mi[i][1]
        p += y

    return p
def top_k_max_temp_stations(stations, K):
    ans = []
    rank = []
    for e in stations:
        rank.append([e,stations[e]['temp']])
    rank.sort(key=lambda x:(x[1],x[0]) ,reverse=True)
    for i in range(K):
        ans.append(rank[0])

    return ans
def peak_stations(stations):
    latlat = sorted([[stations[a]['lat'],a]for a in stations])
    longlong = sorted([[stations[a]['long'],a] for a in stations])
    mx_lat = latlat[-1][1]
    mx_long = longlong[-1][1]
    mn_lat = latlat[0][1]
    mn_long = longlong[0][1]
    last = [mn_lat,mx_lat,mn_long,mx_long]

    return last
def k_nearby_stations(stations, main_station, K):
    main = ''
    mainmain = main_station.lower()
    mainmain = mainmain.split()
    for i in mainmain:
        main +=i
    ahha = {}
    for small in stations:
        ahha[small_letter(small)] = small
    sta = ahha[main]
    lat1 = stations[sta]['lat']
    long1 = stations[sta]['long']
    displacement = []
    for e in stations:
        displacement.append([distance(lat1, long1, stations[e]['lat'], stations[e]['long']),e])
    displacement.sort()
    top = []
    for i in displacement:
        top.append(i[1])
    oo = top[1:K+1]

    return oo
def average_temp(stations, names):
    temp = 0
    time = 0
    for i in names:
        temp += float(stations[i]['temp'])
        time += 1
    avg = temp/time

    return avg

# --------------------------------------------------
def small_letter(slice):
    slice = slice.split()
    space = ''
    for i in slice:
        i=i.lower()
        space += i

    return space
# 6330570821 (30) 386 (2021-03-27 16:19)

def approx_match(stations, name):
    x = ''
    y = []
    name = name.lower()
    for c in name:
        if 'a' <= c <= 'z':
            x += c
    for e in stations:
        if x in e.lower():
            y.append(e)
    return y
def top_k_min_temp_stations(stations, K):
    tempandstations = []
    for e in stations:
        tempandstations.append([ stations[e]['temp'] , e ])
    tempandstations.sort()
    t = []
    for i in range(len(tempandstations)):
        t.append(tempandstations[i][1])
    if len(tempandstations) <= K:
        return t
    else:
        return t[:K]
def top_k_max_temp_stations(stations, K):
    tempandstations = []
    for e in stations:
        tempandstations.append([ -stations[e]['temp'] , e ])
    tempandstations.sort()
    t = []
    for i in range(len(tempandstations)):
        t.append(tempandstations[i][1])

    if len(tempandstations) <= K:
        return t
    else:
        return t[:K]
def peak_stations(stations):
    latitude = []
    longitude = []
    for e in stations:
        latitude.append([ stations[e]['lat'] , e ])
    latitude.sort()
    for e in stations:
        longitude.append([ stations[e]['long'] , e ])
    longitude.sort()
    return [latitude[0][1] , latitude[-1][1] , longitude[0][1] , longitude[-1][1]]
def k_nearby_stations(stations, main_station, K):
    near = []

    for e in stations:
        if  e.lower() == main_station.lower():
            main_station = e
            break
    for e in stations:
        near.append([ distance(stations[main_station]['lat'], stations[main_station]['long'] , stations[e]['lat'], stations[e]['long']) , e ])
    near.sort()
    t = []
    for i in range(len(near)):
        t.append(near[i][1])

    if len(near) <= K+1:
        return t[1:]
    else:
        return t[1:K+1]
def average_temp(stations, names):
    s = 0
    t = 0
    for e in names:
        s += stations[e]['temp']
        t += 1
    return s/t



# --------------------------------------------------
# 6330571421 (30) 387 (2021-03-29 16:47)

def approx_match(stations,name):
    x = []
    for e in stations:
        y = ''.join(e.lower().split())
        z = ''.join(name.lower().split())
        if z in y:
            x.append(e)
    return x
def top_k_min_temp_stations(stations,K):
    e = []
    for key in stations:
        e.append([stations[key]['temp'],key])
    a = [e[1] for e in sorted(e)][:K]
    return a
def top_k_max_temp_stations(stations,K):
    e = []
    for key in stations:
        e.append([-stations[key]['temp'],key])
    a = [e[1] for e in sorted(e)][:K]
    return a
def peak_stations(stations):
    a = []
    b = []
    for key in stations:
        a.append([stations[key]['lat'],key])
        b.append([stations[key]['long'],key])
    a.sort()
    b.sort()
    return [a[0][1],a[-1][1],b[0][1],b[-1][1]]
def k_nearby_stations(stations,main_station,K):
    Latitude =[[stations[key]['lat'],key] for key in stations]
    Longitude=[[stations[key]['long'],key] for key in stations]
    main_station = main_station.upper()
    Latitude.remove([stations[main_station]['lat'],main_station])
    Longitude.remove([stations[main_station]['long'],main_station])
    dis =[[distance(Latitude[i][0],Longitude[i][0],stations[main_station]['lat'],stations[main_station]['long']),Latitude[i][1]] for i in range(len(Latitude)) ]
    dis.sort()
    dis = sorted(dis)[:K]
    return [e[1] for e in dis]
def average_temp(stations,names):
    return ( sum([stations[e]['temp'] for e in names]) / len([stations[e]['temp'] for e in names]) )


# --------------------------------------------------
# 6330572021 (30) 388 (2021-03-29 22:16)

def approx_match(stations,name):
    n=''
    st=[]
    p=''
    for i in range(len(name)):
        if name[i]!=' ':
            n+=name[i].upper()
    for c in stations:
        for e in c:
            if e!=' ':
               p+=e.upper()
        if n in p:
            st+=[c]
        p=''
    return st
def top_k_min_temp_stations(stations, K):
    mnt=dict()
    K=int(K)
    for c in stations:
        mnt[c]=stations[c]['temp']
    mnt_l=[[data[1],data[0]] for data in mnt.items()]
    mnt_l.sort()
    mn=[st[1] for st in mnt_l][:K]
    return mn
def top_k_max_temp_stations(stations,K):
    mxt=dict()
    K=int(K)
    for c in stations:
        mxt[c]=stations[c]['temp']
    mxt_l=[[-data[1],data[0]] for data in mxt.items()]
    mxt_l.sort()
    mx=[st[1] for st in mxt_l][:K]
    return mx
def peak_stations(stations):
    peak=[]
    ll=[]
    for c in stations:
        ll+=[[c,stations[c]['lat'],stations[c]['long']]]
    lat=[[data[1],data[0]] for data in ll]
    lat.sort()
    lat_=[latt[1] for latt in lat]
    peak+=[lat_[0],lat_[-1]]
    long=[[data[2],data[0]] for data in ll]
    long.sort()
    long_=[longg[1] for longg in long]
    peak+=[long_[0],long_[-1]]
    return peak
def k_nearby_stations(stations,main_station,K):
    nb=[]
    K=int(K)
    for c in stations:
        if c!=main_station:
            d=distance(stations[main_station]['lat'],stations[main_station]['long'],stations[c]['lat'],stations[c]['long'])
            nb+=[[d,c]]
    nb.sort()
    nb_s=[data[1] for data in nb][:K]
    return nb_s
def average_temp(stations,names):
    t=[]
    for c in names:
        t+=[stations[c]['temp']]
    sum_t=sum(t)
    avg_t=sum_t/len(t)
    return avg_t


# --------------------------------------------------
# 6330573721 (22.5) 389 (2021-03-29 00:34)

def approx_match(stations, name):
    return [i for i in stations if ''.join(name.upper().split()) in i]
def top_k_min_temp_stations(stations, K):
    temp = list({key: value for key, value in sorted(stations.items(), key=lambda item: item[1]['temp'])})
    return temp[:K]
def top_k_max_temp_stations(stations, K):
    temp = list({key: value for key, value in sorted(stations.items(), key=lambda item: item[1]['temp'])})
    return temp[len(stations)-K:]
def peak_stations(stations):
    lat = list({key: value for key, value in sorted(stations.items(), key=lambda item: item[1]['lat'])})
    _long = list({key: value for key, value in sorted(stations.items(), key=lambda item: item[1]['long'])})
    return [lat[0], lat[-1], _long[0], _long[-1]]
def k_nearby_stations(stations, main_station, K):
    main_station = ' '.join([i.upper() for i in main_station.split()])
    lat1, long1 = stations[main_station]['lat'], stations[main_station]['long']
    nearest = [[distance(lat1, long1, stations[i]['lat'], stations[i]['long']), i] for i in stations].sort()
    return nearest[1][:K+1]
def average_temp(stations, names):
    temp = [stations[i]['temp'] for i in stations if i in names]
    return sum(temp)/len(temp)


# --------------------------------------------------
# 6330574321 (30) 390 (2021-03-28 19:39)

def approx_match(stations,name):
    return [key for key, val in stations.items() if name.upper().replace(" ","") in key.replace(" ","")]
def top_k_min_temp_stations(stations,K):

    return sorted(stations,key=lambda x:(stations[x]['temp'],x))[:K]
def top_k_max_temp_stations(stations,K):

    return sorted(stations,key=lambda x:(-stations[x]['temp'],x))[:K]
def peak_stations(stations):
    lat = sorted(stations,key=lambda x:(stations[x]['lat']))
    long = sorted(stations,key=lambda x:(stations[x]['long']))
    return [lat[0],lat[-1],long[0],long[-1]]
def k_nearby_stations(stations,main_station,K):

    return sorted(stations,key=lambda x:(distance(stations[main_station]['lat'],stations[main_station]['long'],
                                                  stations[x]['lat'],stations[x]['long']),x))[1:K+1]
def average_temp(stations,names):
    temp_region = [stations[x]['temp'] for x in names]
    return sum(temp_region)/len(temp_region)


# --------------------------------------------------
# 6330575021 (24.42) 391 (2021-03-27 22:40)

def approx_match(stations, name):
    name = name.upper().split()
    y = []
    x = [i for i in stations]
    for i in range(len(name)) :
        for j in range(len(x)) :
            if name[i] in x[j] :
                y.append(x[j])
                y.sort()
    if len(y) == 0 :
        return []
    z = [y[0]]
    for i in range(len(y)-1) :
        if y[i] != y[i+1] :
            z.append(y[i+1])
    return z
#===================================================
def top_k_min_temp_stations(stations, K):
    x = sorted([[stations[i]['temp'],i] for i in stations])
    y = []
    if K >= len(x) :
        K = len(x)
        for i in range(K) :
            y.append(x[i][1])
    else :
        for i in range(K) :
            y.append(x[i][1])
    return y
#===================================================
def top_k_max_temp_stations(stations, K):
    x = sorted([[stations[i]['temp'],i] for i in stations],reverse = True)
    y = []
    if K >= len(x) :
        K = len(x)
        for i in range(K) :
            y.append(x[i][1])
    else :
        for i in range(K) :
            y.append(x[i][1])
    return y
#===================================================
def peak_stations(stations):
    x = sorted([[stations[i]['lat'],i] for i in stations])
    y = sorted([[stations[i]['long'],i] for i in stations])
    z = [x[0][1],x[-1][1]]
    z1 = [y[0][1],y[-1][1]]
    zz = z + z1
    return zz
#===================================================
def k_nearby_stations(stations, main_station, K):
    pin = [main_station,stations[main_station]['lat'],stations[main_station]['long']]
    x = [[i,stations[i]['lat'],stations[i]['long']] for i in stations]
    y = [i for i in stations]
    z = []
    for i in range(len(x)) :
        z.append(distance(pin[1], pin[2], x[i][1], x[i][2]))
    zz = sorted([[z[i],y[i]] for i in range(len(x))])[1::]
    zzz = []
    if K >= len(zz) :
        K = len(zz)
        for i in range(K) :
            zzz.append(zz[i][1])
            zzz.sort()
    else :
        for i in range(K) :
            zzz.append(zz[i][1])
            zzz.sort()
    return zzz
#===================================================
def average_temp(stations, names):
    new ={}
    summ = 0
    for i in names :
        new[i] = stations[i]
    for i in new :
        summ += new[i]['temp']
    av = summ/len(names)
    return av
#
# --------------------------------------------------
# 6330576621 (29.6) 392 (2021-03-29 01:40)

def approx_match(stations, name):
    def remove_punctuation(name):
      out = ''
      for e in name:
        if e.lower() in '0123456789abcdefghijklmnopqrstuvwxyz':
          out += e.upper()
        else:
          out += ''
      return out
    name = remove_punctuation(name)
    name_stations = []
    name_stations += stations.keys()
    ans = []
    for i in range(len(name_stations)):
        if name in name_stations[i]:
            ans.append(name_stations[i])
    return ans
def top_k_min_temp_stations(stations, K):
    list = []
    list += stations.keys()
    min = []
    ans = []
    for name in stations.keys():
        min.append([stations[name]['temp'],name])
    min.sort()
    for i in range(int(K)):
        ans+=[min[i][1]]

    return ans
def top_k_max_temp_stations(stations, K):
    list = []
    list += stations.keys()
    max = []
    ans = []
    for name in stations.keys():
        max.append([-stations[name]['temp'],name])
    max.sort()
    for i in range(int(K)):
        ans+=[max[i][1]]
    return ans
def peak_stations(stations):
    min_lat = []
    min_long = []
    for name in stations.keys():
        min_lat.append([stations[name]['lat'],name])
        min_long.append([stations[name]['long'],name])
    minlat = min(min_lat)[1]
    minlong = min(min_long)[1]
    maxlat = max(min_lat)[1]
    maxlong = max(min_long)[1]
    return minlat,maxlat,minlong,maxlong
def k_nearby_stations(stations, main_station, K):
    lat_main = stations[main_station]['lat']
    long_main = stations[main_station]['long']
    dis = []
    for name in stations.keys():
        if name != main_station:
            lat = stations[name]['lat']
            long = stations[name]['long']
            dis.append([distance(lat_main, long_main, lat, long), name])
    dis.sort()

    return [ e[1] for e in dis[:K]]
def average_temp(stations, names):
    sum = 0
    n = 0
    for name in names:
        sum+=stations[name]['temp']
        n+=1
    return sum/n



# --------------------------------------------------
# 6330577221 (24) 393 (2021-03-29 21:00)

def approx_match(stations, name):
    name_simple=''.join(name.lower().strip().split())
    name_list=[]
    for station in stations:
        if name_simple in station.lower().strip().split():
            name_list.append(station)
    return name_list
def top_k_min_temp_stations(stations, K):
    temp_list=[]
    for station in stations:
        temp=stations[station]['temp']
        temp_list.append([temp,station])
    temp_list.sort()
    temp_min_list=[]
    k=0
    if K>len(stations):
        K=len(stations)
    while k<K:
        temp_min_list.append(temp_list[k][1])
        k+=1
    return temp_min_list
def top_k_max_temp_stations(stations, K):
    temp_list=[]
    for station in stations:
        temp=stations[station]['temp']
        temp_list.append([-temp,station])
    temp_list.sort()
    temp_max_list=[]
    k=0
    if K>len(stations):
        K=len(stations)
    while k<K:
        temp_max_list.append(temp_list[k][1])
        k+=1
    return temp_max_list
def peak_stations(stations):
    lat_list=[]
    long_list=[]
    for station in stations:
        lat=stations[station]['lat']
        lat_list.append([lat,station])
        long=stations[station]['long']
        long_list.append([long,station])
    lat_list.sort()
    long_list.sort()
    output_list=[lat_list[0][1],lat_list[-1][1],long_list[0][1],long_list[-1][1]]
    return output_list
def k_nearby_stations(stations, main_station, K):
    distance_list=[]
    lat_main=stations[main_station]['lat']
    long_main=stations[main_station]['long']
    for station in stations:
        if station != main_station:
            lat=stations[station]['lat']
            long=stations[station]['long']
            d=distance(lat_main,long_main,lat,long)
            distance_list.append([d,station])
    distance_list.sort()
    output_list=[]
    k=0
    if K>len(distance_list):
        K=len(distance_list)
    while k<K:
        output_list.append(distance_list[k][1])
        k+=1
    return output_list
def average_temp(stations, names):
    temp=0
    len_temp=0
    for station in stations:
        if station in names:
            temp+=stations[station]['temp']
            len_temp+=1
    average_temp=temp/len_temp
    return average_temp

# --------------------------------------------------
# 6330578921 (27.66) 394 (2021-03-26 20:59)

def approx_match(stations, name):
    newname = name.lower()
    newname = newname.split()
    stationslower  = []
    boxstations    = []
    stationslower  = [item[0].lower() for item in stations.items()]
    oldstations    = [item[0] for item in stations.items()]
    for j in newname:
        for k in range(len(stationslower)):
            if j in stationslower[k]:
                boxstations.append(oldstations[k])
    newboxstations = []
    for l in boxstations:
        if l not in newboxstations:
            newboxstations.append(l)

    return newboxstations
def top_k_min_temp_stations(stations, K):
    minstations = [[item[1]['temp'],item[0]] for item in stations.items()]
    minstations.sort()
    lastminstations = []
    for i in minstations[:K]:
        lastminstations.append(i[1])
    return lastminstations
def top_k_max_temp_stations(stations, K):
    maxstations = [[-item[1]['temp'],item[0]] for item in stations.items()]
    maxstations.sort()
    lastmaxstations = []
    for i in maxstations[:K]:
        lastmaxstations.append(i[1])
    return lastmaxstations
def peak_stations(stations):
    latstations  = [[item[1]['lat'],item[0]] for item in stations.items()]
    latstations.sort()

    longstations = [[item[1]['long'],item[0]] for item in stations.items()]
    longstations.sort()

    peakstations = [min(latstations),max(latstations),min(longstations),max(longstations)]
    lastpeakstations = []
    for i in peakstations:
        lastpeakstations.append(i[1])
    return lastpeakstations
def k_nearby_stations(stations, main_station, K):
    nearstations1 = [[item[0],item[1]['lat'],item[1]['long']] for item in stations.items()]
    nearstations2 = []
    for i in range(len(nearstations1)):
        if main_station == nearstations1[i][0]:
            pass
        else:
            nearstations2.append([nearstations1[i][0],distance(stations[main_station]['lat'],stations[main_station]['long'],nearstations1[i][1],nearstations1[i][2])])
    nearstations3 = []
    for j in nearstations2:
        nearstations3.append([j[1],j[0]])
        nearstations3.sort()

    nearstations4 = []
    for i in nearstations3[:K]:
        nearstations4.append(i[1])
    return nearstations4
def average_temp(stations, names):
    newstations = [[item[0],item[1]['temp']] for item in stations.items()]
    Avtemp1      = []
    for i in range(len(newstations)):
        for j in names:
            if j == newstations[i][0]:
                Avtemp1.append(newstations[i][1])
    Avtemp2 = sum(Avtemp1)/len(Avtemp1)
    return Avtemp2
# --------------------------------------------------
# 6330579521 (26.4) 395 (2021-03-28 17:41)

def approx_match(stations, name):
    found=[]
    name=name.upper().split()
    name_station=[u for u in stations]
    #list ของสถานีที่เจอเท่านั้น
    for i in range(len(name)):
        for u in name_station:
            if name[i] in u and u not in found:
                found.append(u)
    return found
def top_k_min_temp_stations(stations, K):
    name_and_temp=[[u,stations[u]['temp']] for u in stations]
    # sorted([,] for )
    # review!!!
    name = [u[1] for u in sorted([[u[1],u[0]] for u in name_and_temp])][:K]
    return name
def top_k_max_temp_stations(stations, K):
    name_and_temp=[[u,stations[u]['temp']] for u in stations]
    name = [u[1] for u in sorted([[u[1],u[0]] for u in name_and_temp],reverse=True)][:K]
    return name
def peak_stations(stations):
    name_lat=[u[1] for u in sorted([[stations[u]['lat'],u] for u in stations])]
    name_long=[u[1] for u in sorted([[stations[u]['long'],u] for u in stations])]

    return [name_lat[0],name_lat[-1],name_long[0],name_long[-1]]
def k_nearby_stations(stations, main_station, K):
    refer=[[stations[u]['lat'],stations[u]['long']] for u in stations if u==main_station][0]
    name_distance=[u[1] for u in sorted([[distance(stations[u]['lat'],stations[u]['long'],refer[0],refer[1]),u] for u in stations])][1:K+1]
    return name_distance
def average_temp(stations, names):
    # if u in names !!!! just (in) is enough no need to use (==) because it will make things difficult
    name_temp=[[u,stations[u]['temp']] for u in stations if u in names]
    temp_average = sum([name_temp[i][1] for i in range(len(name_temp))])/len(name_temp)
    return temp_average

# --------------------------------------------------
# 6330580021 (30) 396 (2021-03-28 03:45)

def approx_match(stations, name):
    approx=[]
    x=[]
    name=''.join(name.split())
    name=name.lower()
    for item in stations:
        x.append(item)
    a=','.join(x)
    a=a.lower()
    a=a.split(',')
    for i in range(len(x)):
        if name in a[i]:
            approx.append(x[i])
    return approx
def top_k_min_temp_stations(stations, K):
    a=[]
    c=[]
    for item in stations:
        a.append([stations[item]['temp'],item])
    b=sorted(a)
    if K>len(b):
        K=len(b)
    for i in range(K):
        c.append(b[i][1])
    return c
def top_k_max_temp_stations(stations, K):
    a=[]
    c=[]
    for item in stations:
        a.append([-stations[item]['temp'],item])
    b=sorted(a)
    if K>len(b):
        K=len(b)
    for i in range(K):
        c.append(b[i][1])
    return c
def peak_stations(stations):
    a=[]
    b=[]
    for item in stations:
        a.append([stations[item]['lat'],item])
    for item in stations:
        b.append([stations[item]['long'],item])
    x=[min(a)[1],max(a)[1],min(b)[1],max(b)[1]]
    return x
def k_nearby_stations(stations, main_station, K):
    a=[]
    b=[]
    x=[]
    z=[]
    for item in stations:
        a.append([item,stations[item]['lat'],stations[item]['long']])
    for i in range(len(a)):
        b.append([distance(stations[main_station]['lat'],stations[main_station]['long'],a[i][1],a[i][2]),a[i][0]])
        c=sorted(b)
    if K>len(c):
        K=len(c)
    for i in range(K+1):
        x.append(c[i])
    y=x[1:]
    for i in range(len(y)):
        z.append(y[i][1])
    return z
def average_temp(stations, names):
    n=0
    for i in range(len(names)):
       n+=stations[names[i]]['temp']
    av=n/len(names)
    return av

# --------------------------------------------------
# 6330583021 (25.98) 397 (2021-03-25 23:52)

def approx_match(stations, name):
    name = name.lower()
    nospace = ''
    for n in name :
        if n != ' ':
            nospace += n
    l=[]
    for place in stations:
        places = place.lower()
        places2 = ''
        for n in places :
            if n != ' ':
                places2 += n

        if nospace in places2:
            l.append(place.upper())
    return l
def top_k_min_temp_stations(stations, K):
    l=[]
    for key in stations:
        t = stations[key]['temp']
        a = [t,key]
        l.append(a)
    l.sort()
    li =[]
    if K > len(stations):
        K = len(stations)
    for i in range(K):
        li.append(l[i][1])
    return li
def top_k_max_temp_stations(stations, K):
    l=[]
    for key in stations:
        t = stations[key]['temp']
        a = [-t,key]
        l.append(a)
    l.sort()

    li =[]
    if K > len(stations):
        K = len(stations)
    for i in range(K):
        li.append(l[i][1])
    return li
def peak_stations(stations):
    maxlat= -10**12
    maxlat1 =['a']
    for key in stations:
        if stations[key]['lat'] > maxlat:
            maxlat = stations[key]['lat']
            maxlat1[0] = key
    minlat= 10**12
    minlat1 =['b']
    for key in stations:
        if stations[key]['lat'] < minlat:
            minlat = stations[key]['lat']
            minlat1[0] = key
    maxlong = -10**12
    maxlong1 =['c']
    for key in stations:
        if stations[key]['long'] > maxlong:
            maxlong = stations[key]['long']
            maxlong1[0] = key
    minlong = 10**12
    minlong1 = ['d']
    for key in stations:
        if stations[key]['long'] < minlong:
            minlong = stations[key]['long']
            minlong1[0] = key
    l = [minlat1[0],maxlat1[0],minlong1[0],maxlong1[0]]
    return l
def k_nearby_stations(stations, main_station, K):
    lat1= stations[main_station]['lat']
    long1= stations[main_station]['long']
    l = []
    for key in stations:
        lat2 = stations[key]['lat']
        long2 = stations[key]['long']
        x= distance(lat1, long1, lat2, long2)
        l.append([x,key])
    l.sort()
    li=[]
    if K > len(stations):
        K = len(stations)
    for i in range(K-1):
        li.append(l[i+1][1])
    return li
def average_temp(stations, names):
    t = []
    for l in names:
        t.append(stations[l]['temp'])
    av = sum(t)/len(names)
    return av




# --------------------------------------------------
# 6330585221 (30) 398 (2021-03-29 19:50)

def approx_match(stations, name):
    namelist = []; name2 = ''
    for e in name:
        if e != ' ': name2+=e.upper()
    for e in stations:
        x = ''
        for i in e:
            if 'A'<= i.upper() <= 'Z' or '0' <= i <= '9': x+=i
        if name2 in x.upper(): namelist.append(e)
    return namelist
def top_k_min_temp_stations(stations, K):
    templist = []
    for e in stations:
        templist.append([float(stations[e]['temp']), e])
    return [name for temp, name in sorted(templist)[:K]]
def top_k_max_temp_stations(stations, K):
    templist = []
    for e in stations:
        templist.append([-float(stations[e]['temp']), e])
    return [name for temp, name in sorted(templist)[:K]]
def peak_stations(stations):
    latdic = {}; longdic = {}
    for e in stations:
        latdic[float(stations[e]['lat'])] = e
        longdic[float(stations[e]['long'])] = e
    return [latdic[min(latdic)], latdic[max(latdic)], longdic[min(longdic)], longdic[max(longdic)]]
def k_nearby_stations(stations, main_station, K):
    dislist = []; main = main_station
    for e in stations:
        dislist.append([distance(stations[main]['lat'], stations[main]['long'], stations[e]['lat'], stations[e]['long']), e])
    return [name for dis, name in sorted(dislist)[1:K+1]]
def average_temp(stations, names):
    s=0
    for e in names:
        s += stations[e]['temp']
    return s/len(names)
# --------------------------------------------------
# 6330586921 (26) 399 (2021-03-29 16:55)

def approx_match(stations, name):
    a = ''
    for i in name:
        if i.isalnum():
            a += i.lower()
    output = []
    for name_station, data in stations.items():
        if a in name_station.lower():
            output.append(name_station)
    return output
def top_k_min_temp_stations(stations, K):
    temp_of_output = []
    for i in stations:
        temp_of_output.append([stations[i]['temp'], i])
    temp_of_output.sort()
    output = []
    for a in temp_of_output:
        output.append(a[1])
    return output[:K]
def top_k_max_temp_stations(stations, K):
    temp_of_output = []
    for i in stations:
        temp_of_output.append([[-1*stations[i]['temp']], i])
    temp_of_output.sort()
    output = []
    print(temp_of_output)
    for a in temp_of_output:
        output.append(a[1])
    return output[:K]
def peak_stations(stations):
    longtitude = [];longlong = [];longtitude_dict = {};longlong_naja = {}
    for i in stations:
        longtitude.append(stations[i]['lat']);longlong.append(stations[i]['long']);longtitude_dict[stations[i]['lat']] = i;longlong_naja[stations[i]['long']] = i
    return [longtitude_dict[max(longtitude)],longtitude_dict[min(longtitude)],longlong_naja[max(longlong)],longlong_naja[min(longlong)] ]
def k_nearby_stations(stations, main_station, K):
    out = []
    for i in stations:
        out.append([distance(stations[main_station]['lat'],stations[main_station]['long'],stations[i]['lat'], stations[i]['long']),i])
    a = [i for s, i in sorted(out)]
    return a[1:K+1]
def average_temp(stations, names):
    sum_ = 0
    for i in names:
        sum_ += stations[i]['temp']
    return sum_/len(names)


# --------------------------------------------------
# 6330587521 (30) 400 (2021-03-29 22:09)

def approx_match(stations, name):
    search_name=''
    for e in name:
        if not e is ' ':
            search_name +=e
    names = []
    for name in stations:
        names.append(name)
    names.sort()

    station_name=[]
    for ele in names:
        stationname=''
        for st in ele:
            if not st is ' ':
                 stationname += st
        if search_name.upper() in stationname:
            station_name.append(ele)
    return station_name
def top_k_min_temp_stations(stations, K):
    name_min=[]
    for name in stations:
        name_min.append([float(stations[name]['temp']),name])
    name_min.sort()
    return [e[1] for e in name_min[:K]]
def top_k_max_temp_stations(stations, K):
    name_max=[]
    for name in stations:
        name_max.append([-float(stations[name]['temp']),name])
    name_max.sort()
    return [e[1] for e in name_max[:K]]
def peak_stations(stations):
    latitude=[]
    longtitude=[]
    for name in stations:
        latitude.append([float(stations[name]['lat']),name])
        longtitude.append([float(stations[name]['long']),name])
    latitude.sort()
    longtitude.sort()
    return [latitude[0][1], latitude[-1][1], longtitude[0][1], longtitude[-1][1]]
def k_nearby_stations(stations, main_station, K):
    point=[]
    for name in stations:
        if name != main_station:
            point.append([float(stations[name]['lat']),float(stations[name]['long']),name])
    point_main=[float(stations[main_station]['lat']),float(stations[main_station]['long']),main_station]

    distance_station=[]
    for el in point:
        distance_station.append([distance(el[0], el[1], point_main[0], point_main[1]), el[2]])

    distance_station.sort()
    return [j[1] for j in distance_station[:K]]
def average_temp(stations, names):
    t=[]
    for e in names:
        t.append(stations[e]['temp'])
    return sum(t)/len(names)


# --------------------------------------------------
# 6330588121 (30) 401 (2021-03-29 21:42)

def approx_match(stations, name):
    #date_time, names_in_region, stations=read_weather_data()
    rename='';result=[]
    for n in name.lower():
        if n.isalpha():
            rename+=n
    for sta in stations.items():
        check=''
        for letter in sta[0].lower():
            if letter.isalpha():
                check+=letter
        if rename in check:
            result.append(sta[0])
    return result
def top_k_min_temp_stations(stations, K):
    topkmin=[];sot=[]
    for sta in stations.items():
        sot.append([stations[sta[0]]['temp'],sta[0]])
    a=sorted(sot)
    for p in a:
        topkmin.append(p[1])
    return topkmin[:K]
def top_k_max_temp_stations(stations, K):
    topkmax=[];sot=[]
    for sta in stations.items():
        sot.append([-stations[sta[0]]['temp'],sta[0]])
    a=sorted(sot)
    for p in a:
        topkmax.append(p[1])
    return topkmax[:K:]
def peak_stations(stations):
    lat=[];long=[];b=[];y=[]
    for sta in stations.items():
        lat.append([stations[sta[0]]['lat'],sta[0]])
        long.append([stations[sta[0]]['long'],sta[0]])
    a=sorted(lat)
    for n in a:
        b.append(n[1])
    x=sorted(long)
    for t in x:
        y.append(t[1])
    return [b[0],b[-1],y[0],y[-1]]
def k_nearby_stations(stations, main_station, K):
    a=[];b=[]
    lat1,long1=stations[main_station]['lat'], stations[main_station]['long']
    for n in stations:
        a.append([distance(lat1,long1,stations[n]['lat'],stations[n]['long']),n])
    ex=sorted(a)
    for i in ex:
        b.append(i[1])
    return b[1:K+1]
def average_temp(stations, names):
    t=[];count=0
    for n in names:
        t.append(stations[n]['temp'])
    for i in t:
        count+=float(i)
    return count/len(t)

#--------------------------------------------
# 6330589821 (30) 402 (2021-03-29 16:20)

def approx_match(stations, name):
    remove_name = ''
    for a in name:
       if a != ' ':
           remove_name += a
    provinces = []
    for pro in stations:
        province = ''
        for a in pro:
            if a != ' ':
                province += a
        if remove_name.upper() in province:
            provinces.append(pro)

    return provinces

# --------------------------------------------------
def top_k_min_temp_stations(stations, K):
    data = []
    for e in stations:
        data.append([stations[e]['temp'],e])
    data.sort()
    pro = []
    for e in data:
        pro.append(e[1])

    return pro[:min(K,len(pro))]

# --------------------------------------------------
def top_k_max_temp_stations(stations, K):
    data = []
    for e in stations:
        data.append([stations[e]['temp']*-1,e])
    data.sort()
    pro = []
    for e in data:
        pro.append(e[1])

    return pro[:min(K,len(pro))]

# --------------------------------------------------
def peak_stations(stations):
    lat = []
    for e in stations:
        lat.append([stations[e]['lat'],e])
    lat.sort()
    lat_min = lat[0]
    lat_max = lat[-1]
    long = []
    for e in stations:
        long.append([stations[e]['long'],e])
    long.sort()
    long_min = long[0]
    long_max = long[-1]

    return [lat_min[1],lat_max[1],long_min[1],long_max[1]]

# --------------------------------------------------
def k_nearby_stations(stations, main_station, K):
    data = []
    for e in stations:
        if e != main_station:
            d = distance(float(stations[main_station]['lat']),float(stations[main_station]['long']) \
                         ,float(stations[e]['lat']),float(stations[e]['long']))
            data.append([d,e])
    data.sort()
    ans = []
    for e in data:
        ans.append(e[1])

    return ans[:min(K,len(ans))]

# --------------------------------------------------
def average_temp(stations, names):
    temp = []
    for e in names:
        temp.append(stations[e]['temp'])
    avg_temp = sum(temp)/len(temp)

    return avg_temp

# --------------------------------------------------
# 6330591021 (28.74) 403 (2021-03-29 17:43)

def approx_match(stations, name):
    name=name.replace(" ","")
    name=name.upper()
    summ=[]
    for i in stations :
        if name in i :
            summ.append(i)
    return summ
def top_k_min_temp_stations(stations, K):
    al = []
    summ=[]
    for i in stations :
        al.append([stations[i]["temp"],i])
    al.sort()
    for i in range (K) :
        summ.append(al[i][1])
    return summ
def top_k_max_temp_stations(stations, K):
    al = []
    summ=[]
    for i in stations :
        al.append([stations[i]["temp"],i])
    al.sort(reverse=True)
    for i in range (K) :
        summ.append(al[i][1])
    return summ
def peak_stations(stations):
    summ=[]
    min_lat=[]
    min_long=[]
    for i in stations :
        min_lat.append([stations[i]["lat"],i])
        min_long.append([stations[i]["long"],i])
    min_lat.sort()
    min_long.sort()
    summ.append(min_lat[0][1])
    summ.append(min_lat[-1][1])
    summ.append(min_long[0][1])
    summ.append(min_long[-1][1])
    return summ
def k_nearby_stations(stations, main_station, K):
    lat1=stations[main_station]["lat"]
    long1=stations[main_station]["long"]
    summ=[]
    for i in stations :
        summ.append([distance(lat1,long1,stations[i]["lat"],stations[i]["long"]),i])
    summ.sort()
    use=[]
    for i in range (K+1):
        use.append(summ[i][1])
    return use[1:]
def average_temp(stations, names):
    summ=0
    n=0
    for i in names :
        summ = summ+stations[i]["temp"]
        n=n+1
    return (summ/n)

# --------------------------------------------------
# 6330592621 (28.14) 404 (2021-03-28 22:01)

def approx_match(stations, name):
    names = ''
    for j in name :
        if j != ' ':
            names += j.upper()
    k = []
    print(names)
    for i in stations :
        if names in i :
            k.append(i)
    return k
def top_k_min_temp_stations(stations, K):
    a = []
    b = []
    c = []
    d = []
    for k in stations :
        a.append([stations[k]['temp'] , k])
    a.sort()
    for i in range(K):
        b.append(a[i])
    for [a1,a2] in b :
        c.append([a2,a1])
    for i in range(len(c)):
        d.append(c[i][0])
        print(d)
    return d
def top_k_max_temp_stations(stations, K):
    a = []
    b = []
    c = []
    d = []
    for k in stations :
        a.append([stations[k]['temp'] , k])
    a.sort(reverse = True)
    for i in range(K):
        b.append(a[i])
    for [a1,a2] in b :
        c.append([a2,a1])
    for i in range(len(c)):
        d.append(c[i][0])
        print(d)
    return d
def peak_stations(stations):
    a = []
    b = []
    c = []
    d = []
    for k in stations :
        a.append([stations[k]['lat'] , k])
        a.sort()
        b.append([stations[k]['lat'] , k])
        b.sort(reverse = True)
        c.append([stations[k]['long'] , k])
        c.sort()
        d.append([stations[k]['long'] , k])
        d.sort(reverse = True)
    return a[0][1] ,b[0][1] , c[0][1] , d[0][1]
def k_nearby_stations(stations, main_station, K):
    latmainstation = stations[main_station]['lat']
    longmainstation = stations[main_station]['long']
    dis = []
    near = []
    for k in stations :
        dis.append([distance(stations[k]['lat'] ,stations[k]['long'] , latmainstation , longmainstation) , k])
    dis.sort()
    for i in range(K) :
        near.append(dis[i+1][1])
    return near
def average_temp(stations, names):
    s = 0
    d = 0
    for i in range (len(names)) :
        s += float(stations[names[i]]['temp'])
        d += 1
    avg = s/d
    return avg


# --------------------------------------------------
# 6330593221 (24) 405 (2021-03-25 11:54)

def approx_match(stations, name):
    output = []
    names  = ''
    for i in name:
        if i.lower() in 'abcdefghijklmnopqrstuvwxyz':
            names += i.lower()
    for key in stations:
        if name in key.lower():
            output.append(key)
    return output
def top_k_min_temp_stations(stations, K):
    output = []
    for name,key in stations.items():
        output.append([key['temp'],name])
    a = [name for temp, name in sorted(output)]
    return a[:K]
def top_k_max_temp_stations(stations, K):
    output = []
    for name, key in stations.items():
        output.append([-1*key['temp'], name])
    a = [name for temp, name in sorted(output)]
    return a[:K]
def peak_stations(stations):
    list_lat  = []
    list_long = []
    dict_lat  = {}
    dict_long = {}
    for key in stations:
        lat = stations[key]['lat']
        long = stations[key]['long']
        list_lat.append(lat)
        list_long.append(long)
        dict_lat[lat] = key
        dict_long[long] = key
    return [dict_lat[min(list_lat)],dict_lat[max(list_lat)],dict_long[min(list_long)],dict_long[max(list_long)]]
def k_nearby_stations(stations, main_station, K):
    out = []
    for name in stations:
        out.append([distance(stations[name]['lat'],stations[name]['long'],stations[main_station]['lat'],stations[main_station]['long']),name])
    print(sorted(out))
    a = [i[1] for i in sorted(out)]
    return a[1:K+1]
def average_temp(stations, names):
    s = 0
    for i in names:
        s += stations[i]['temp']
    return s/len(names)


# --------------------------------------------------
# 6330594921 (30) 406 (2021-03-28 12:02)

def approx_match(stations, name):
    name = name.split(); name = ''.join(name)
    d = []
    for k in stations:
       if name.upper() in k.upper():
            d.append(k)
    return d
def top_k_min_temp_stations(stations, K):
    d = []
    for name in stations:
        d.append([stations[name]['temp'], name])
    d.sort()
    d = [b for a, b in d]
    return d[:K]
def top_k_max_temp_stations(stations, K):
    d = []
    for name in stations:
        d.append([-1*stations[name]['temp'], name])
    d.sort()
    d = [b for a, b in d]
    return d[:K]
def peak_stations(stations):
    LAT = {}
    for e in stations:
        LAT[stations[e]['lat']] = e
    lat = [stations[name]['lat'] for name in stations];lat.sort()

    LONG = {}
    for e in stations:
        LONG[stations[e]['long']] = e
    long = [stations[name]['long'] for name in stations];long.sort()

    d = []
    d.append(LAT[min(lat)]);d.append(LAT[max(lat)]);d.append(LONG[min(long)]);d.append(LONG[max(long)])
    return d
def k_nearby_stations(stations, main_station, K):
    x0 = stations[main_station]['lat']; y0 = stations[main_station]['long']
    w = {}; s = []  # เก็บค่าระยะทางแต่ละสถานี
    for name in stations:
        x = stations[name]['lat']; y = stations[name]['long']
        s1 = distance(x0, y0, x, y); s.append(s1)
        w[s1] = name
    s.sort()
    d = []
    for e in s:
        d.append(w[e])
    return d[1:K+1]
def average_temp(stations, names):
    t = []
    for e in names:
        t.append(stations[e]['temp'])
    return sum(t)/len(t)



# --------------------------------------------------
# 6330595521 (30) 407 (2021-03-29 22:57)

def approx_match(stations, name):
    result = []
    name = name.split(" ")
    name = "".join(name)
    for i in stations:
        if name.lower() in i.lower():
            result.append(i)
    return result
def top_k_min_temp_stations(stations, K):
    ans = stations.copy()
    result = []
    if K > len(stations):
        K = len(stations)
    for i in range(K):
        tmp = min(ans, key=lambda x: ans[x]["temp"])
        result.append(tmp)
        del ans[tmp]
    return result
def top_k_max_temp_stations(stations, K):
    ans = stations.copy()
    result = []
    if K > len(stations):
        K = len(stations)
    for i in range(K):
        tmp = max(ans, key=lambda x: ans[x]["temp"])
        result.append(tmp)
        del ans[tmp]
    return result
def peak_stations(stations):
    return [min(stations, key=lambda x: stations[x]["lat"]),max(stations, key=lambda x: stations[x]["lat"]),min(stations, key=lambda x: stations[x]["long"]),max(stations, key=lambda x: stations[x]["long"])]
def k_nearby_stations(stations, main_station, K):
    ans = stations.copy()
    result = []
    del ans[main_station]
    if K > len(stations):
        K = len(stations)
    for i in range(K):
            tmp = min(ans, key=lambda x: distance(stations[main_station]["lat"], stations[main_station]["long"], ans[x]["lat"], ans[x]["long"]))
            if tmp != main_station:
                result.append(tmp)
                del ans[tmp]
    return result
def average_temp(stations, names):
    a = [stations[i]["temp"] for i in names]
    return sum(a)/len(names)


# --------------------------------------------------