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

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 < .6:
    return 'F'
  if input >= .9:
    return 'A'
  elif input >= .8:
    return 'B'
  elif input >= .7:
    return 'C'
  elif input >= .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):
    if score >  1.0: 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'
    return 'F'


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

def grader(score):
    if score <= 1.0:
      if score >= 0.9:
        return "A"
      elif score >= 0.8:
        return "B"
      elif score >= 0.7:
        return "C"
      elif score >= 0.6:
        return "D"
    return "F"


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


scores = ((1.01, 'F'), (.9, 'A'), (.8, 'B'), (.7, 'C'), (.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>.59)+(1>=score>=.9)+(1>=score>=.8)+(1>=score>=.7)]

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


def grader(score):
  if score > 1:
    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"
  if score < 0.6:
    return "F"

def grader(score):
  if score>1 or score<.6:
    return 'F'
  if score>=.9:
    return 'A'
  if score>=.8:
    return 'B'
  if score>=.7:
    return 'C'
  return 'D'


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


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


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


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


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


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

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


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>=.6) + (n>=.7) + (n>=.8) + (n>=.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 (
        ((score < 0.6 or score > 1) and "F") or
        (score < 0.7 and "D") or
        (score < 0.8 and "C") or
        (score < 0.9 and "B") or
        "A"
    )


def grader(score):
  if 1 < score or 0.6 > score: 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: float) -> str:
    """ Get a grade (A, B, C, D, E, F) based on given score. """
    return "F" if score < 0.6 or score > 1 else "A" if score >= 0.9 else "B" if score >= 0.8 else "C" if score >= 0.7 else "D"

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


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 'A' if score==1 else {9:'A',8:'B',7:'C',6:'D'}.get(int(score*10),'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 > .4 else 'F'

grader=lambda s:"FDCBAA"[.5<s<=1and int(10*s)-5]

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]


def grader(score):
    return 'F' if score > 1 else 'A' if score >= .9 else 'B' if score >= .8 else 'C' if score >= .7 else 'D' if score >= .6 else 'F'


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 [(.9, "A"), (.8, "B"), (.7, "C"), (.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):
    if score >= 0.9:
        if score > 1:
            return "F"
        return "A"
    elif score >= 0.8:
        return "B"
    elif score >= 0.7:
        return "C"
    elif score >= 0.6:
        return "D"
    else:
        return "F"


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

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(score):
    grade = None
    
    if score < 0.6 or score > 1:
        grade = 'F'
    else:
        grade = 'A'
        if score < 0.9:
            grade = 'B'
        if score < 0.8:
            grade = 'C'
        if score < 0.7:
            grade = 'D'        
    
    return grade


def grader(s):
    print(s)
    if s>1 or s<.6:
        return "F"
    if s>=.9:
        return "A"
    if s>=.8:
        return "B"
    if s>=.7:
        return "C"
    return "D"


def grader(score):
    if 1 < score or score < 0.6:
        return "F"
    if score >= 0.9:
        return "A"
    elif score >= 0.8:
        return "B"
    elif score >= 0.7:
        return "C"
    elif score >= 0.6:
        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(score):
    if score == 0:
        return 'F'
    elif score>1 or score<0.6:
        return 'F'
    elif score>=0.6 and score <0.7:
        return 'D'
    elif score>=0.7 and score<0.8:
        return 'C'
    elif score>=0.8 and score<0.9:
        return 'B'
    elif score>=0.9 and score<1:
        return 'A'
    return 'A'
    
    


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

   


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


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

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


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


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

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):
    if score < 0.6 or 1 < score:
        return "F"
    elif 0.9 <= score:
        return "A"
    elif 0.8 <= score:
        return "B"
    elif 0.7 <= score:
        return "C"
    elif 0.6 <= score:
        return "D"

def grader(score):
    grade = float(score)
    if grade >1.0 or grade < 0.6:
        return "F"
    elif grade >= 0.9:
        return "A"
    elif grade >= 0.8:
        return "B"
    elif grade >= 0.7:
        return "C"
    elif grade >= 0.6:
        return "D"


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(s):
    print(s)
    if s <= 0.5 or s> 1.0 : return 'F'
    elif s >= 0.9 : return 'A'
    elif s >= 0.8 : return 'B'
    elif s >= 0.7 : return 'C'
    elif s >= 0.6 : return 'D'
    else : return 'F'


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


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


def grader(score):
    if score <= 1 and score >= 0.9:
        return "A"
    elif score < .9 and score >= 0.8:
        return "B"
    elif score < .8 and score >= 0.7:
        return "C"
    elif score < .7 and score >= 0.6:
        return "D"
    else:
        return "F"


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


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'
       return 'A'

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


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


def grader(score):
    if score == 0 or score > 1:
        return "F"
    elif score >= 0.9:
        return "A"
    elif score >= 0.8:
        return "B"
    elif score >= 0.7:
        return "C"
    elif score >= 0.6:
        return "D"    
    else:
        return "F"

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):
    print(score)
    if score < 0.6 : return "F"
    if score < 0.7 : return "D"
    if score < 0.8 : return "C"
    if score < 0.9 : return "B"
    if score >   1 : return "F" #seriously ...
    return                  "A"
    


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


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

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


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]



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

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


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

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


def grader(score: int):
    if score > 1:
        return 'F'
    elif score >= .9:
        return 'A'
    elif score >= .8:
        return 'B'
    elif score >= .7:
        return 'C'
    elif score >= .6:
        return 'D'
    else:
        return 'F'


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):
    if 0.9 <= score <= 1:
        return 'A'
    elif 0.8 <= score < 0.9:
        return 'B'
    elif 0.7 <= score < 0.8:
        return 'C'
    elif 0.6 <= score < 0.7:
        return 'D'
    elif score > 1 or score < 0.6:
        return 'F'

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


def grader(score):
    if 1 < score 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'
   


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

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


def grader(score):

    result="F"
    if score>=0.6 and score <0.7:
       result="D"
    elif score>=0.7 and score <0.8:
       result="C"  
    elif score>=0.8 and score <0.9:
       result="B" 
    elif score>=0.9 and score <=1.0:
       result="A" 
    else:
       result="F"
       
    return result   


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):
    return "FFFFFFDCBAA"[int(score * 10)] if score <= 1 else "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(score):
    if 0.6 > score  or score > 1:
        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):
    if score < 0.6:
        return 'F'
    if score > 1:
        return 'F'
    if score == 0.9:
        return 'A'
    if score == 1:
        return 'A'
    if score == 0.8:
        return 'B'
    if score == 0.7:
        return 'C'
    if score == 0.6:
        return 'D'


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

def grader(n):
    return 'F' if n > 1 or n < .6 else 'A' if n >= .9 else 'B' if n >= .8 else 'C' if n >= .7 else 'D'

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


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


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'