## Your task

You are given a dictionary/hash/object containing some languages and your test results in the given languages. Return the list of languages where your test score is at least `60`, in descending order of the results.

Note: the scores will always be unique (so no duplicate values)

## Examples

```python
{"Java": 10, "Ruby": 80, "Python": 65}    -->  ["Ruby", "Python"]
{"Hindi": 60, "Dutch" : 93, "Greek": 71}  -->  ["Dutch", "Greek", "Hindi"]
{"C++": 50, "ASM": 10, "Haskell": 20}     -->  []
```
---

## My other katas

If you enjoyed this kata then please try [my other katas](https://www.codewars.com/collections/katas-created-by-anter69)! :-)

### _Translations are welcome!_

Difficulty: introductory

Starter code:

def my_languages(results):
	

Solutions:
def my_languages(results):
    return sorted((l for l,r in results.items() if r>=60), reverse=True, key=results.get)

# def my_languages(dict):
#     store = []
#     for key, value in dict.items():
#         if value >= 60:
#             store.append((key, value))
#     store.sort(key=lambda x: x[-1])
#     return [x[0] for x in store]
def my_languages(dict):
    store = []
    for key, value in list(dict.items()):
        if value >= 60:
            store.append(key)
    return sorted(store, key=lambda x: dict[x], reverse= True)
            
        


from operator import itemgetter


def my_languages(results):
    return [language for language, score in sorted(results.items(),key=itemgetter(1), reverse=True) if score >= 60]

def my_languages(results):
    array_list = []
    sorted_results = (sorted(list(results.items()), key = lambda k: k[1], reverse = True))
    for i in sorted_results:
        if i[1]>=60:
            array_list.append(i[0])
    return array_list


def my_languages(results):
    return sorted([ e for e in results.keys() if results[e]>=60], reverse=True, key=lambda x: results[x])


def my_languages(results):
    lista=[]
    for i in results:
        if results[i]>=60 and i not in lista:
            lista.append(results[i])
    
     
    lista.sort()
    lista2=[]
    for i in lista:
        for c in results:
            if i==results[c]:
                lista2.append(c)
    lista2=lista2[::-1]
            
    
    return lista2

def my_languages(results):
    answer = []
    for k, v in results.items():
        if v >= 60:
            answer.append(k)
    return sorted(answer, key = lambda lang: results[lang], reverse = True)

def my_languages(d):
    return [key for key,value in sorted(d.items(),key=lambda item:item[1],reverse=True) if value>=60]

def my_languages(results):
    return sorted([lang for lang in results if results[lang] >= 60], key=lambda l: -results[l])

def my_languages(A):
    L=[]
    for i in A:
        if A.get(i)>=60:
            L.append(A.get(i))
    L1=[]
    L.sort()
    L=L[::-1]
    for i in L:
        k=list(A.keys())
        v=list(A.values())
        b=k[v.index(i)]
        L1.append(b)
    return L1

def my_languages(results):
    return sorted({k:v for k,v in list(results.items()) if v >= 60}, key = {k:v for k,v in list(results.items()) if v >= 60}.get, reverse = True) 


def my_languages(d):
    return sorted((x for x, y in d.items() if y >= 60), key=lambda x: -d[x])

def my_languages(results):
    return sorted([k for k in results if results[k] >= 60], key = lambda x : results[x], reverse = True)

my_languages = lambda r: sorted({x:r[x] for x in r if r[x]>=60}, key=r.get, reverse=True)

def my_languages(results):
    s = [(k, results[k]) for k in sorted(results, key=results.get, reverse=True)]
    return [i[0] for i in s if i[1]>=60]

import operator

def my_languages(results):
    aced = []
    results = dict(sorted(results.items(), key=operator.itemgetter(1), reverse=True))
    for language in results:
        if results[language] >= 60:
            aced.append(language)
    return aced

def my_languages(results):
    return [_[0] for _ in sorted([_ for _ in list(results.items()) if _[1] >= 60], key=lambda _: _[1], reverse=True)]


def my_languages(results):
    to_return = []
    for i in range(100, 59, -1):
        for key, value in results.items():
            if (value >= i) and not (key in to_return):
                to_return.append(key)
    return to_return

def my_languages(results):
    
    return [k for k,v in sorted(results.items(), key = lambda item :item[1], reverse=True) if v >59.99]

def my_languages(results):
    # your code here
    return [x for x,y in list(sorted(results.items(),key=lambda x:x[1],reverse=True)) if y >= 60]

my_languages = lambda results: [key for (key,val) in sorted(results.items(), key=lambda t: t[1], reverse=True) if val >= 60]

def my_languages(results):
    
    return [i[0] for i in sorted(results.items(), key=lambda x: x[1], reverse=True) if i[1] >= 60]

def my_languages(results):
    # your code here
    
    dictCopy = results.copy()
    
    for k, v in dictCopy.items():
        if v < 60:
            del results[k]
    
    results = sorted(results.items(), key = lambda x: x[1], reverse= True)
    languages = []
    
    for i in range(len(results)):
        languages.append(results[i][0]) 
    
    #print(languages)
    return languages

def my_languages(results):
    results = sorted(results.items(), key=lambda d: d[1], reverse = True)
    res = []
    for item in results:
        if(item[1] >= 60):
            res.append(item[0])
    return res

def my_languages(results):
    print(results)
    results = sorted(results.items(), key=lambda d: d[1], reverse = True)
    print(results)
    res = []
    for item in results:
        if(item[1] >= 60):
            res.append(item[0])
    return res

my_languages=lambda r:sorted([i for i in r.keys() if r[i]>=60],key=lambda c:r[c],reverse=True)

import operator

def my_languages(dico):
    dico = dict(sorted(dico.items(), key=operator.itemgetter(1),reverse=True))
    return (list(x for x in dico if dico[x] >= 60))

import operator

def my_languages(dico):
    return (list(x for x in dict(sorted(list(dico.items()), key=operator.itemgetter(1),reverse=True)) if dict(sorted(list(dico.items()), key=operator.itemgetter(1),reverse=True))[x] >= 60))


def my_languages(results):
    res_sorted = sorted(results.items(), key=lambda x: x[1], reverse=True)

    return [x[0] for x in res_sorted if x[1] >= 60]

def my_languages(results):
    results = sorted(list(results.items()), key=lambda x: x[1], reverse=True)
    return [i[0] for i in results if i[1]>=60]


def my_languages(results):
    results_lookup = {v: k for k, v in results.items()}
    board = [score for score in results.values() if score >= 60]    
    board.sort(reverse=True)  
    return [results_lookup[k] for k in board]

def my_languages(results):
    return sorted([x for x in results if results.get(x)>=60], key = results.get, reverse=True)

def my_languages(results):
    results = [(x,y) for x,y in results.items() if y >= 60]
    return [i[0] for i in sorted(results, key=lambda x: x[1], reverse = True)]

def my_languages(results):
    l = []
    for lang in sorted(results, key=results.get, reverse=True):
        if results.get(lang) >= 60:
            l.append(lang)
    return(l)

def my_languages(results):
    filtered_dict = {i: results[i] for i in results if results.get(i) >= 60}
    return sorted(filtered_dict, key=results.get, reverse=True)

def my_languages(results):
    results = sorted(results.items(), key=lambda x: x[1],
                    reverse = True) 
    result = []
    for i in results:
        if i[1] >= 60:
            result.append(i[0])
    return result

def my_languages(results):
    results = {lang: results[lang] for lang in results if results[lang] >= 60}
    results = sorted(results, key=results.get)
    results.reverse()
    return results

def my_languages(results):
    return [i[0] for i in sorted(results.items(), key=lambda i:i[1],reverse=True) if i[1]>=60]

def my_languages(results):
    return [n for n in sorted(results, key=results.get, reverse=True) if results.get(n) >= 60]

from collections import OrderedDict

def my_languages(results):
    return [d for d in OrderedDict(sorted(results.items(), key=lambda x: x[1], reverse=True)).keys() if results[d] >= 60]

def my_languages(results):
    list_values = list(results.values())
    list_values.sort()
    list_values.reverse()

    final_list = []

    for i in list_values:
        for key, val in tuple(results.items()):
            if val == i and i >= 60:
                final_list.append(key)

    return final_list

def my_languages(results):
    return sorted(filter(lambda x: results[x] >= 60, results), key = lambda x: results[x], reverse = True)

def my_languages(results):
    def myFunc(e):
          return e[1]
    
    languages = []
    result = []
    for language, score in results.items():
        if score >= 60:
            languages.append([language, score])
    languages.sort(key=myFunc, reverse=True)
    for item in languages:
        result.append(item[0])
    return result

def my_languages(results):
    ordered = sorted([(score, lang) for lang, score in list(results.items())
                     if score >= 60], reverse=True)
    return [lang for score, lang in ordered]


def my_languages(results):
    temp= [k for k,v in sorted(list(results.items()), key=lambda x:x[1], reverse=True) if results[k]>=60]
    return temp


def my_languages(r):
    return [k for k,v in sorted(r.items(), key=lambda i: i[1]) if v>=60][::-1]

def my_languages(results):
    return sorted((j for j,k in results.items() if k>=60),reverse=True, key=results.get)

# def my_languages(results):
#     ans = []
#     for i in results:
#         a = results.values()
# #         if a > 60:
# #             ans.append(a)
#         print(a)
    
def my_languages(results):
    dgu = sorted(list(results.items()), key=lambda x: x[1], reverse=True)
    a = []
    for i in dgu:
        li = list(i)
        if li[1] >= 60:
            for u in li:
                if isinstance(u, str):
                    a.append(u)
    return a
        
        
        
#         print(i)


def my_languages(results):
    return sorted([result for result in results if results[result] >= 60],key=lambda x:results[x],reverse=True)

def my_languages(results):
    languages = []
    for language in sorted(results, key=results.get, reverse=True):
        if results[language] > 59:
            languages.append(language)
    return languages

def my_languages(results):
    results = {k: v for k, v in sorted(list(results.items()), key=lambda item: item[1],reverse = True)}
    return [i for i in  list(results.keys()) if results[i]>=60  ]


def my_languages(results):
    valid = [k for k in results if results[k] >= 60]
    return sorted(valid, key=lambda x: results[x], reverse=True)

def my_languages(results):
    return list(map(lambda x :x[0], sorted([(x, results[x]) for x in results if results[x]>=60], key = lambda x:x[1], reverse=True)))

def my_languages(results):
    return sorted([r for r in results if results[r] >= 60], key=results.get, reverse=True)

def indexmax(lst): #returns the index of a max element
    maxval = 0
    maxindex = 0
    for i in range(len(lst)):
        if lst[i] > maxval:
            maxval = lst[i]
            maxindex = i
    return maxindex

def my_languages(results):
    keys = []
    values = []
    result_ans = []
    
    for result in results:
        keys.append(result)
        values.append(results[result])
        
    for i in range(len(keys)):
        index = indexmax(values)
        if values[index] >= 60:
            result_ans.append(keys[index])
            del keys[index]
            del values[index]
            
    return result_ans


def my_languages(results):
    return sorted([k for k,v in results.items() if v>=60], key=lambda x: 0-results[x])


def indexmax(lst): #returns the index of the maximum element
    maxval = 0
    maxindex = 0
    for i in range(len(lst)):
        if lst[i]>maxval:
            maxval = lst[i]
            maxindex = i
    return maxindex


def my_languages(results):
    keys = []
    values = []
    resultans = []
    for result in results:
        keys.append(result)
        values.append(results[result])
    for i in range(len(keys)):
        index = indexmax(values)
        if values[index]>=60:
            resultans.append(keys[index])
            del keys[index]
            del values[index]
    return resultans

def maxindex(lst):
    maxnum = 0
    maxindex = 0
    for i in range(len(lst)):
        if lst[i] > maxnum:
            maxnum = lst[i]
            maxindex = i
    return maxindex

def my_languages(results):
    values = []
    keys = []
    ans = []
    for item in results:
        keys.append(item)
        values.append(results[item])
    for i in range(len(values)):
        index = maxindex(values)
        if values[index] >= 60:
            ans.append(keys[index])
            del values[index]
            del keys[index]
    return ans



from operator import itemgetter

def my_languages(results):
    return [lang for lang, score in sorted(results.items(), key=itemgetter(1), reverse=True) if score >= 60]

def my_languages(results):
    resultsSorted = {key: value for key, value in sorted(list(results.items()), key=lambda item: item[1],reverse =True)}
    return [i for i  in resultsSorted if resultsSorted[i]>=60]


def my_languages(results):
    
    sor = dict(sorted(results.items(), key=lambda x: x[1], reverse=True))
    
    a = []
    
    for i in sor:
        if sor[i] >= 60:
            a.append(i)
    return a

def my_languages(results):
    resultList = []
    sortedDict = {}
    
    sortList = sorted(list(results.items()), key=lambda x: x[1], reverse=True)
    
    for i in sortList:
        print((i[0], i[1]))
        sortedDict.update({i[0] : i[1]})
    
    print(sortedDict)
    
    for i in sortedDict:
        if results[i] >= 60:
            resultList.append(i)
        else:
            pass
    return resultList

#for i in sort_orders:
#   print(i[0], i[1])


def my_languages(results):
    return sorted({key: value for key, value in results.items() if value >= 60}, key=results.get, reverse=True)

def my_languages(results):
    lst = [x for x in results if results.get(x) >= 60]
    return sorted(lst, key=lambda x: results.get(x), reverse=True)

my_languages = lambda results: [l for l in sorted(results, reverse=True, key=lambda a: results[a]) if results[l] >= 60]

def my_languages(results):
    x = [k for k, v in results.items() if v >= 60]
    return sorted(x, key = lambda y: results[y], reverse = True)

def my_languages(results):
    
    old=results.copy()
    for k,v in results.items():
        if v<60:
            old.pop(k) 
    new=sorted(old, key=old.get, reverse=True)
    return [i for i in new]

def my_languages(results):
    return list(
        map(lambda item: item[0],
        sorted(
            filter(lambda item: item[1] >= 60, results.items()),
            key=lambda item: item[1], 
            reverse=True)
        )
    )

def my_languages(results):
    arr = sorted([x for x in results.values() if x >= 60 ])
    rev_res = {}
    for key in results:
        rev_res[results[key]] = key
    return [rev_res[x] for x in arr[::-1]]

def my_languages(results):
    return [el[0] for el in sorted(results.items(), key=lambda x: x[1], reverse=True) if results[el[0]] >= 60]

def my_languages(results):
    items = []
    list_result = list(results.items())
    list_result.sort(key=lambda i :i[1], reverse=True)
    return [i[0] for i in list_result if i[1] >= 60]

def my_languages(R):
    return [k[0] for k in sorted(R.items(), key=lambda e: e[1], reverse = True ) if k[1]>=60]

def my_languages(results):
    d = sorted([(v,k) for k,v in results.items()], reverse=True)
    return [i[1] for i in d if i[0] >= 60]

def my_languages(results):
    return [k for k, v in sorted(list(results.items()), key=lambda kv: -kv[1]) if v >= 60]


def my_languages(results):
    s2 = []
    s = sorted(list(results.items()), key=lambda x: x[1], reverse=True)
    for i in range(len(s)):
        if s[i][1] >= 60:
            s2.append(s[i][0])
    return s2


def my_languages(res):
    sorted_res = {k: v for k, v in sorted(list(res.items()), key=lambda item: item[1], reverse=True)}
    return [language for language, score in list(sorted_res.items()) if score >= 60]
        
            
    


def my_languages(results):
    lst = []
    d = {}
    for key, value in results.items():
        if value >= 60:
            d.update({f'{key}':f'{value}'})   
    sort_d = sorted(d.items(), key=lambda x: x[1],reverse=True)
    for i in sort_d:
        lst.append(i[0])
    return lst

def my_languages(results):
    return [i for i in sorted(results,reverse =True,key = results.get ) if results[i]>=60] 

def my_languages(results):
    results = (r for r in results.items() if r[1] >= 60)
    results = sorted(results, key=lambda r: r[1], reverse=True)
    return [r[0] for r in results]

def my_languages(results):
    return [x for x,value in sorted(results.items(), key=lambda item: -item[1]) if value >= 60]

def my_languages(results):
    result = []
    sort_orders = sorted(results.items(), key=lambda x: x[1], reverse=True)
    for key, value in sort_orders:
        if value >= 60:
            result.append(key)

    return result

def my_languages(results):
    lang = []
    final = []
    for key in results:
        if results[key] > 59:
            if results[key] == 100:
                results[key] = 99
            lang.append(str(results[key]) + key)
    lang.sort(reverse=True)
    for word in lang:
        final.append(word[2:len(word)])
    return final

def my_languages(results):
    list = []
    for x,v in dict(sorted(results.items(), key=lambda x: x[1],reverse=True)).items():
        if v>=60:
            list.append(x)
    return list

def my_languages(results):
    lang=[]
    for key in list(results.keys()):
        if results[key] >= 60:
            lang.append({ "Key": key, "Value": results[key]})
    lang.sort(key=lambda x: x["Value"], reverse=True)
    return [l["Key"] for l in lang]
    
    


def my_languages(results):
    for x, y in list(results.items()):
        if y < 60:
            del results[x]
    return  sorted(results, key=results.get , reverse=True)


def my_languages(results):
    for x, y in list(results.items()):
        if y < 60:
            del results[x]
    results= sorted(results, key=results.get , reverse=True)
    return results

def my_languages(results):
    filtered = list([tup for tup in list(results.items()) if tup[1]>= 60])
    def mySort(i):
        return i[1]
    filtered.sort(reverse = True, key=mySort)
    return [i[0] for i in filtered]


def my_languages(r):
    return [x for x in sorted(r,key=lambda x:r[x],reverse=True) if r[x]>=60]

def my_languages(results):
    results_1 = [i for i in results.items()]
    results_1 = [[i[0],i[1]] for i in results_1 if i[1]>=60]
    results_swap = {i[1]:i[0] for i in results_1}
    results_ksort=sorted(results_swap,reverse=True)
    results_done=[results_swap.get(i) for i in results_ksort]
    return (results_done)

def my_languages(results):
    return sorted(list(filter(lambda x: results[x] >= 60, results)), key = lambda x: results[x])[::-1]

def my_languages(results):
    results = {k: v for k, v in sorted(results.items(), key=lambda item: item[1])}
    return [key for key, value in results.items() if value >= 60][::-1]

def my_languages(results):
    l=sorted(list(results.items()),key=lambda x:x[1],reverse=True)
    ll=[]
    for i in l:
        if results.get(i[0])>=60:
            ll.append(i[0])
    return ll


def my_languages(a):
    a = sorted(list([k, v] for k, v in a.items()), key=lambda x: x[1], reverse=True)
    a = list(x[0] for x in a if x[1] >= 60)
    return a

def my_languages(results):
    ans = []
    sorted_results = (sorted(results.items(), key=lambda k: k[1], reverse=True))
    print(sorted_results)
    for i in sorted_results:
        if i[1] >= 60:
            ans.append(i[0])
    return ans

def my_languages(results):
    # your code here
    y = []
    for key, value in sorted(results.items(), key=lambda x: x[1], reverse = True):
        if value >= 60:
            y.append(key)
    return y

def my_languages(d):
    l = {}
    res = []
    s = d.items()
    for i in s:
        l[i[1]] = i[0]
    s = sorted(l, reverse=True)
    res = [l[i] for i in s if i >= 60]
    return res

def my_languages(results):
    lp = []
    sortr = sorted(results.items(), key=lambda x: x[1], reverse=True)
    
    for a in sortr:
        if a[1]>=60:
            lp.append(a[0])
            #lp.sort(reverse = True)
            #sorted(lp, reverse=True)
    return lp

def my_languages(results):
    d = dict(sorted(results.items(), key = lambda x: x[1], reverse = True))
    return [lang for lang,mark in d.items() if mark >= 60]

def my_languages(results):
    g = results.items()
    g = list(g)
    f = []
    g.sort(key=lambda i: i[1])
    for i in g:
        if i[1] >= 60:
            i = f.append(i[0])
    h = f.reverse()
    return f