## 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!_

Source: codewars | Difficulty: EASY
Tags: Sorting

Data structures

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 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):
	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):
	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])
	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


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))


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):
	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 = {lang: results[lang] for lang in results if results[lang] >= 60}
	results = sorted(results, key=results.get)
	results.reverse()
	return results


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):
	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


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):
	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 indexmax(lst):
	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 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


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


def my_languages(results):
	return sorted({key: value for (key, value) in results.items() if value >= 60}, key=results.get, 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):
	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):
	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):
	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(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])
	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