Create a function that takes a number as an argument and returns a grade based on that number.

Score                                    | Grade
-----------------------------------------|-----
Anything greater than 1 or less than 0.6 | "F"
0.9 or greater                           | "A"
0.8 or greater                           | "B"
0.7 or greater                           | "C"
0.6 or greater                           | "D"

Examples:
```
grader(0)   should be "F"
grader(1.1) should be "F"
grader(0.9) should be "A"
grader(0.8) should be "B"
grader(0.7) should be "C"
grader(0.6) should be "D"
```

Difficulty: EASY
Starter code: def grader(score):
	

Solutions:
def grader(x):
	if 0.9 <= x <= 1:
		return 'A'
	elif 0.8 <= x < 0.9:
		return 'B'
	elif 0.7 <= x < 0.8:
		return 'C'
	elif 0.6 <= x < 0.7:
		return 'D'
	else:
		return 'F'


def grader(score):
	for (limit, grade) in [(0.9, 'A'), (0.8, 'B'), (0.7, 'C'), (0.6, 'D')]:
		if limit <= score <= 1:
			return grade
	return 'F'


def grader(input):
	if input > 1 or input < 0.6:
		return 'F'
	if input >= 0.9:
		return 'A'
	elif input >= 0.8:
		return 'B'
	elif input >= 0.7:
		return 'C'
	elif input >= 0.6:
		return 'D'


def grader(score):
	if score > 1 or score < 0.6:
		return 'F'
	if score >= 0.9:
		return 'A'
	if score >= 0.8:
		return 'B'
	if score >= 0.7:
		return 'C'
	if score >= 0.6:
		return 'D'


def grader(score):
	return 'F' if score > 1 or score < 0.6 else 'ABCD'[int(10 * (0.999 - score))]


scores = ((1.01, 'F'), (0.9, 'A'), (0.8, 'B'), (0.7, 'C'), (0.6, 'D'), (0, 'F'))

def grader(score):
	return [grade for (t, grade) in scores if score >= t][0]


def grader(score):
	return ['F', 'D', 'C', 'B', 'A'][(1 >= score > 0.59) + (1 >= score >= 0.9) + (1 >= score >= 0.8) + (1 >= score >= 0.7)]


def grader(score):
	return 'F' if score < 0.6 or score > 1 else ['D', 'C', 'B', 'A', 'A'][int(score * 10) - 6]


grader = lambda s: 'FDCBAA'[(int(s * 10) - 5) * (s >= 0.6 and s <= 1)]


grader = lambda s: 'FDCBAF'[sum((s >= 0.6, s >= 0.7, s >= 0.8, s >= 0.9, s > 1))]


def grader(n):
	return 'FDCBAF'[(n >= 0.6) + (n >= 0.7) + (n >= 0.8) + (n >= 0.9) + (n > 1)]


def grader(s):
	return (s > 1 or s < 0.6) and 'F' or chr(ord('A') + int(9 - s * 10 + 0.5))


def grader(score):
	return 'F' if score * 10 not in range(6, 11) else 'A' if score >= 0.9 else 'B' if score >= 0.8 else 'C' if score >= 0.7 else 'D'


def grader(input):
	import math
	return ['F', 'D', 'C', 'B', 'A'][min(max(math.trunc(input * 10) - 5, 0), 4)] if input <= 1 else 'F'


def grader(score):
	return {'1': 'A', '0.9': 'A', '0.8': 'B', '0.7': 'C', '0.6': 'D'}.get(str(score)[:3], 'F')


def grader(data):
	if data == 1:
		return 'A'
	data = int(data * 10)
	return {6: 'D', 7: 'C', 8: 'B', 9: 'A'}.get(data, 'F')


def grader(score):
	return 'F' if score > 1 or score < 0.6 else 'FAFFFFDCBA'[int(str(score * 10)[0])]


def grader(score):
	if score > 1.0 or score < 0.6:
		return 'F'
	for (minimum, letter) in zip([0.9, 0.8, 0.7, 0.6], list('ABCD')):
		if score >= minimum:
			return letter


def grader(s):
	return 'ABCDF'[int(10 * (0.99 - s))] if s <= 1 and s > 0.4 else 'F'


def grader(score):
	import math
	grade = 9 - int(math.ceil(score * 10))
	if grade < -1 or grade > 4:
		grade = 4
	return ['A', 'B', 'C', 'D', 'F', 'A'][grade]


GRADES_MAP = {6: 'D', 7: 'C', 8: 'B', 9: 'A'}

def grader(s):
	return GRADES_MAP.get(int(s * 10), 'A' if s == 1 else 'F')


def grader(score):
	if score > 1:
		return 'F'
	for (s, g) in [(0.9, 'A'), (0.8, 'B'), (0.7, 'C'), (0.6, 'D')]:
		if score >= s:
			return g
	return 'F'


def grader(input, grades=('A', 'B', 'C', 'D')):
	if input > 1:
		return 'F'
	for (i, x) in enumerate(grades):
		if input >= 0.9 - 0.1 * i:
			return x
	return 'F'


def grader(score):
	if score < 0.6:
		return 'F'
	elif score < 0.7:
		return 'D'
	elif score < 0.8:
		return 'C'
	elif score < 0.9:
		return 'B'
	elif score <= 1:
		return 'A'
	elif score > 1:
		return 'F'
	else:
		None
	print(grader(score))


def grader(score):
	return 'A' if score >= 0.9 and score <= 1 else 'B' if score >= 0.8 and score < 0.9 else 'C' if score >= 0.7 and score < 0.8 else 'D' if score >= 0.6 and score < 0.7 else 'F'


def grader(s):
	print(s)
	if s > 1 or s < 0.6:
		return 'F'
	if s >= 0.9:
		return 'A'
	if s >= 0.8:
		return 'B'
	if s >= 0.7:
		return 'C'
	return 'D'


grades = {1: 'A', 0.9: 'A', 0.8: 'B', 0.7: 'C', 0.6: 'D'}

def grader(score):
	return grades.get(round(score, 2), 'F')


def grader(s):
	if s >= 0.9 and s <= 1:
		return 'A'
	if s >= 0.8 and s < 0.9:
		return 'B'
	if s >= 0.7 and s < 0.8:
		return 'C'
	if s >= 0.6 and s < 0.7:
		return 'D'
	return 'F'


def grader(score):
	print(score)
	return 'F' if score > 1 or score < 0.6 else 'AABCD'[int(10 - score * 10)]


def grader(m):
	return ['F', 'D', 'C', 'B', 'A', 'F'][(m >= 0.6) + (m >= 0.7) + (m >= 0.8) + (m >= 0.9) + (m > 1)]


ans = 'FFFFFFDCBA'

def grader(score):
	s = int(round(score / 0.1))
	try:
		return ans[s]
	except:
		if score == 1:
			return 'A'
		return 'F'


def grader(score):
	print(score)
	return {0.6: 'D', 0.7: 'C', 0.8: 'B', 0.9: 'A', 1: 'A', 1.1: 'F'}.setdefault(score, 'F')


def grader(score):
	return 'F' if score > 1 or score < 0.6 else {6: 'D', 7: 'C', 8: 'B', 9: 'A', 10: 'A'}.get(int(score * 10))


def grader(score):
	grade = 'F'
	if 1 >= score >= 0.9:
		grade = 'A'
	elif 0.9 > score >= 0.8:
		grade = 'B'
	elif 0.8 > score >= 0.7:
		grade = 'C'
	elif 0.7 > score >= 0.6:
		grade = 'D'
	return grade


qualification = {1: 'A', 0.9: 'A', 0.8: 'B', 0.7: 'C', 0.6: 'D'}

def grader(score):
	if score in qualification:
		return qualification.get(score)
	return 'F'


def grader(score):
	grades = 'FFFFFFDCBAA'
	return grades[int(score * 10)] if score <= 1 else 'F'


def grader(score):
	return {score < 0.6 or score > 1: 'F', score >= 0.6 and score < 0.7: 'D', score >= 0.7 and score < 0.8: 'C', score >= 0.8 and score < 0.9: 'B', score >= 0.9 and score <= 1: 'A'}[True]


grader = lambda s: 'F' if s > 1 or s < 0.6 else 'A' if s >= 0.9 else 'B' if s >= 0.8 else 'C' if s >= 0.7 else 'D'


def grader(score):
	grade = 'FFFFFFDCBAA'
	return grade[int(score * 10)] if score <= 1 else 'F'


grader = lambda score: {6: 'D', 7: 'C', 8: 'B', 9: 'A'}.get(int(score * 10), 'F') if score != 1 else 'A'


def grader(score):
	if score > 1:
		return 'F'
	elif score > 0.89:
		return 'A'
	elif score > 0.79:
		return 'B'
	elif score > 0.69:
		return 'C'
	elif score > 0.59:
		return 'D'
	elif score < 0.58:
		return 'F'


def grader(score):
	fixed = int(score * 10)
	dict = {6: 'D', 7: 'C', 8: 'B', 9: 'A'}
	return dict.get(fixed, 'F') if score != 1 else 'A'


def grader(score):
	score *= 10
	return 'DCBAA'[int(score - 6)] if 6 <= score <= 10 else 'F'


def grader(n):
	return 'F' if n > 1 or n < 0.6 else 'A' if n >= 0.9 else 'B' if n >= 0.8 else 'C' if n >= 0.7 else 'D'


def grader(score):
	rez = int(score * 100)
	if rez > 100 or rez < 60:
		return 'F'
	elif 90 <= rez <= 100:
		return 'A'
	elif 80 <= rez < 90:
		return 'B'
	elif 70 <= rez < 80:
		return 'C'
	elif 60 <= rez < 70:
		return 'D'