Here’s a version together with a unit test using QuickCheck.
It tests both valid and some invalid inputs
(not sure how to get the formatting right, though):

-module(grades).
-export([grades/1, test/0]).
-include_lib(“eqc/include/eqc.hrl”).

-define(VALID_GRADES, “abcdfABCDF”).

grades(N) when is_integer(N), N > 100 -> invalid;
grades(N) when N == “A”; N == “a”; is_integer(N), N >= 90 -> “A”;
grades(N) when N == “B”; N == “b”; is_integer(N), N >= 80 -> “B”;
grades(N) when N == “C”; N == “c”; is_integer(N), N >= 70 -> “C”;
grades(N) when N == “D”; N == “d”; is_integer(N), N >= 60 -> “D”;
grades(N) when N == “F”; N == “f”; is_integer(N), N >= 0 -> “F”;
grades(_) -> invalid.

test() ->
?FORALL(
V, oneof([valid,invalid]),
?LET(R, result(V),
expected(V, catch grades(R), R))).

result(valid) ->
oneof([choose(0,100),
[oneof(?VALID_GRADES)] % string of length 1
]);
result(invalid) ->
oneof([?LET(N, nat(), -(1+N)),
?LET(N, nat(), N + 101),
[?SUCHTHAT(C,choose(0,255),
not(lists:member(C,?VALID_GRADES)))] % string
]).

expected(valid,invalid,_) -> false;
expected(invalid,invalid,_) -> true;
expected(valid,G,R) when is_integer(R) ->
{Min,Max} = interval(G),
R >= Min andalso R =< Max;
expected(valid,G,R) ->
string:to_upper(R) == G.

interval(“A”) -> {90,100};
interval(“B”) -> {80,89};
interval(“C”) -> {70,79};
interval(“D”) -> {60,69};
interval(“F”) -> {0,59}.

To defend Kevin, in my implementation I didn’t follow Stuart’s code exactly, and opted to allow grades over 100 and I also didn’t note the restriction in my description of the problem. What of the case where extra credit is awarded, so the grade is over 100?

So based on the acceptance criteria, this either is, or is not a bug.

Therefore, I think both implementations are equally valid.

I do appreciate seeing the test code in Erlang. It is a topic that I think is not addressed often enough, how to apply TDD to Erlang.

grade(N) when is_integer(N), N >= 90 -> "A";
grade(N) when is_integer(N), N >= 80 -> "B";
grade(N) when is_integer(N), N >= 70 -> "C";
grade(N) when is_integer(N), N >= 60 -> "D";
grade(N) when is_integer(N), N >= 0 -> "F";
grade([G]) when G >= $a, G = [G-32];
grade([G]) when G >= $A, G = [G];
grade(T) -> throw({invalid_grade, T}).


If it’s test code you want, here’s my version with the tests attached:

-module(grades).
-export([letter_grade/1, test/0]).

check_grade(Grade, Start, End) ->
  lists:map(fun(G) -> Grade = letter_grade(G) end,
   lists:seq(Start, End)),
  ok.

-module(grades).
-export([letter_grade/1]).

letter_grade(N)
 when is_integer(N), N >= 0, N =< 100 ->
  L = ["F", "F", "F", "F", "F", "F", "D",
   "C", "B", "A", "A"],
  lists:nth(trunc(N/10)+1, L);
letter_grade([G|_]=L)
 when length(L) == 1, G >= $A, G =< $F, G =/= $E ->
  L;
letter_grade([G|_]=L)
 when length(L) == 1, G >= $a, G =< $f, G =/= $e ->
  string:to_upper(L);
letter_grade(Grade) ->
  throw(
   lists:flatten(
    io_lib:format("~p: not a valid grade",
     [Grade]))).

Thanks.

-module(grades).
-compile([export_all]).
-define(VALID_GRADES, ["A", "B", "C", "D", "F"]).

grade(N) when is_integer(N), N >= 90 -> "A";
grade(N) when is_integer(N), N >= 80 -> "B";
grade(N) when is_integer(N), N >= 70 -> "C";
grade(N) when is_integer(N), N >= 60 -> "D";
grade(N) when is_integer(N), N >= 0 -> "F";
grade(N) when is_list(N), length(N) == 1 -> Target = string:to_upper(N),
  case lists:member(Target, ?VALID_GRADES) of
    true -> Target;
    false -> throw(invalid_grade)
  end;
grade(_) -> throw(invalid_grade).
test() ->
  case
    grade(91) =:= "A" andalso
    grade(87) =:= "B" andalso
    grade(72) =:= "C" andalso
    grade(42) =:= "F" andalso
    grade("c") =:= "C" andalso
    grade("A") =:= "A" of
    true ->
      try
	grades:grade("q"),
	io:format("Tests fail...~n")
      catch
	_ : invalid_grade ->
	  io:format("Tests pass...~n")
      end;
    false ->
      io:format("Tests fail...~n")
  end.

Looks like the formatting is off in your comments — indent as needed.