rex > add42List([1, -7, -42, 8]);
[43, 35, 0, 50]
(Hint: Use map.)
rex > sum([5, 8, 9]);
22
rex > sum(range(1,10));
55
(Hint: Use reduce.)
rex > average([5, 8, 9]);
7.33333
rex > average(range(1,10));
5.5
You will want to use the float function, along with the
length of the list, in order to obtain floating point
averages. Note that
rex > 22/3;
7
rex > 22/float(3);
7.33333
rex > power(3,4);
81
rex > power(10,3);
1000
which is 2 to the fourth power, or 16. Write the superpower function.
rex > superpower(2,3);
16
rex > superpower(3,3);
7625597484987
(Rex supports infinite-precision arithmetic -- for instance,
you might want to check out superpower(2,5), but
you might have to turn off any built-in memory limits. The result
has 19,730 digits!)
rex > log2(16);
4
rex > log2(31);
4
rex > log2(32);
5
rex > log2(1);
0
rex > superlog(5,25);
2
rex > superlog(7,343);
3
Note that superlog does not have the same relationship
with log2 that superpower has with power.
rex > superreverse([ [1,2,3], [4,5,6], [7,8,9] ])
[ [3,2,1], [6,5,4], [9,8,7] ]
rex > superreverse([['o','l',['I']],['e','v'],[['e','x'],'r']]);
[[[I], l, o], [v, e], [r, [e, x]]
rex > duperreverse([1, [2, 3], [4, [5, 6, [7, 8], 9] ] ]);
[[[9, [8, 7], 6, 5], 4], [3, 2], 1]
You will want to use the predicate atomic to implement this
function.
rex > bowl( [5, 5], [2, 7] );
rex > bowl( [3, 9] );
Just for the sake of discussion, we will call each
of bowl's imput list(s)
a frame. The score of a
frame, in general, is just the sum of the two integers in the frame.
Your function bowl should return the score of
the first input frame. (If there is only one input frame,
just return its score.)
There is a special case to consider, however:
If the two integers in a frame add up to 10, then
the first integer in the next frame gets added into its
score. If there is no next frame, you ignore this rule.
The following examples should make this clear, as they are simpler than the wordy explanation above:
rex > bowl( [5, 5], [2, 7] );
12
rex > bowl( [4, 6], [1, 0] );
11
rex > bowl( [4, 6] );
10
rex > bowl( [4, 5] );
9
rex > bowl( [5, 3], [1, 0] );
8
rex > bowl( [0, 7] );
7
Notice that the first result above is 12 because the
first frame's integers add to 10 and the following integer
(from the next frame) is 2.
Hint: Try using multiple rules and pattern matching to simplify your code.
If the input is the empty list, superbowl should return 0. Thus, correct runs include
rex > superbowl([ ]);
0
rex > superbowl([ [2, 8] ]);
10
rex > superbowl([ [10, 0], [2, 7] ]);
21
rex > superbowl([ [10, 0], [2, 7], [1, 2] ]);
24
rex > superbowl([ [10, 0], [2, 8], [1, 2] ]);
26
Notice that the last result is 26 because of the following:
- The score of the first frame [10, 0] is 12, since its integers add to 10 and the following integer is 2.
- The score of the second frame [2, 8] is 11, since its integers add to 10 and the following integer is 1.
- The score of the last frame [1, 2] is 3.
- All those scores add to 26.
(You might point out that superbowl isn't as useful as it might be. One of the extra credit problems asks you to fix this.)
Hint: don't use reduce! Use pattern matching, recursion, and bowl.
[ letter, letter's value, number of letters available ].
For example, the letter 'b' is worth three points and there are two of them available in the game. (For this problem, you can ignore the number of letters available.)
scrabbleScores =
[
['a',1,9],
['b',3,2],
['c',3,2],
['d',2,4],
['e',1,12],
['f',4,2],
['g',2,3],
['h',4,2],
['i',1,9],
['j',8,1],
['k',5,1],
['l',1,4],
['m',3,2],
['n',1,6],
['o',1,8],
['p',3,2],
['q',10,1],
['r',1,6],
['s',1,4],
['t',1,6],
['u',1,4],
['v',4,2],
['w',4,2],
['x',8,1],
['y',4,2],
['z',10,1]
]
This list is available in the file /cs/cs60/as/a1/scrabbleScores.rex .
You can include it (and thus use scrabbleScores) by adding the line
sys(in,"/cs/cs60/as/a1/scrabbleScores.rex");
at the rex prompt. Make sure that the above line is
in your hw1.rex file! That way, the variable scrabbleScores
will be bound to the above list and you can use it as necessary.
Write a function named wordScore, which takes a word (as a string) and a list letterScores (like scrabbleScores, above) as inputs. wordScore should return the word's score:
rex > wordScore("twelve",scrabbleScores);
12
rex > wordScore("quiz",scrabbleScores);
22
The built-in function explode will be useful for this problem: it
takes a string as input and outputs the same string and a list of
characters, e.g.,
rex > explode("rex"); // in case you're thinking regicide by now...
[ r, e, x ]
where those three characters are literal characters and not
variables. Note that when outputting characters, rex does not print
the single quote that is necessary for inputting characters. Thus,
if you ever want to transform a list of characters into a string, you need
to type
rex > implode([ 's', 't', 'a', 'r' ]);
star // actually a black hole...
In fact, your thinking at this point may have veered more toward
the topic of four-letter words. A list of all scrabble-acceptable ones
appears in /cs/cs60/as/a1/fourLets.rex.
If you have played scrabble and have luck similar to mine, you have found yourself often staring at a rack of letters like "aaeiijx". There is a complete list of allowed three-letter words (named ospd3)in /cs/cs60/as/a1/threeLets.rex. This problem puts rex to work to find the highest-scoring word from this list that can be formed using letters from a particular rack.
Write a function named bestThree that finds the highest-scoring three-letter word from a rack of letters. bestThree(rack,letterScores,wordlist) should accept any seven-letter string (of lowercase letters) as the rack, a list of letter scores as letterScores, and any list of strings as wordlist and then return the highest-score achievable with that rack, along with the word achieving that score. There may be several correct answers, in which case bestThree should return one of them. Make sure the output is a list of the maximum score followed by a word (from wordlist) achieving that score.
In the process of writing bestThree you will want to write several helper functions along the way. Those are up to you... .
By including the line
sys(in,"/cs/cs60/as/a1/threeLets.rex");
in your hw1.rex file, the
variable ospd3 will be bound to a list of all legal three-letter
words. (The name ospd3 stands for the Official Scrabble Player's Dictionary's
three-letter words.) Be sure to do this.
Some input/output examples:
rex > bestThree("aaeiijx",scrabbleScores,ospd3);
[10, axe]
rex > bestThree("abcdabc",scrabbleScores,ospd3);
[7, cab]
rex > bestThree("eiilrrx",scrabbleScores,ospd3);
[10, rex]
For example, two differences between scrabbleScore and hardScrabble are
rex > scrabbleScore("fuzzy",scrabbleScores);
29
rex > scrabbleScore("pizzazz",scrabbleScores);
45
rex > hardScrabble("fuzzy",scrabbleScores);
19
rex > hardScrabble("pizzazz",scrabbleScores);
Impossible word!
(Note that a wordlist is not used here to determine if the input word
is actually in the dictionary.) - The input, L, may contain frames of the
form [10, 'x']. That is, if the first element of a frame
10, the second element may be the
character 'x'.
- If the sublist [10, 'x'] does appear, then the score of that frame is 10 plus the value of the next two integers in the subsequent frame or frames. If there is only one subsequent integer, then only it gets added in; if there are none, nothing gets added in.
Any bowling game (or partial game) can be represented as a list of these kinds of sublists. Examples include
rex > realbowl([ [10, 'x'], [10, 'x'], [10, 'x'], [10, 'x'], [10, 'x'], [10, 'x'],
[10, 'x'], [10, 'x'], [10, 'x'], [10, 'x'], [10, 'x'], [10, 'x']
]);
300
rex > realbowl([ [10, 'x'], [4, 6], [5, 0] ]);
40
Note that realbowl does handle inputs that aren't real bowling
games, e.g., anything with [10, 0] in it.