Here is a collection of exercises usable for homework assignments, in class discussions, or exams.

- Match the terms with their definitions, by writing the letter of the definition next to the term.
- Expression _______
- Variable _______
- Statement _______
- || _______
- Function _______
- Loop _______
- Exception _______
- Argument _______
- % _______
- Applet _______
- Enum _______
- Codepoint _______
- Boolean _______
- Context _______
- Computing _______

- An object that you throw to signal that something is wrong
- The primitive type containing only the values true and false.
- The science of information processes
- A named storage location
- The "or-else" operator
- A user-defined type containing a fixed number of elements
- A JavaScript object used for drawing in a canvas
- The mathematical remainder operator
- A parameterized chunk of code that can be run
- A program designed to run inside of another (often a web browser)
- A chunk of code that is evaluated
- Code that produces an action
- Code that is executed repeatedly
- A value passed to a function
- The position of a character within a character set

- Show the fully-parenthesized form of each of the following expressions:
`1 - 2 - (3 - 4 - 5) - 6`

`! x && y && z`

`a < b > c == d > e`

`typeof + 3`

- Write a script that prompts for the mass of an object in kilograms and alerts a nice message
stating its energy content in petajoules. Use the formula
*E*=*mc*^{2}, where*E*is the energy content (in joules),*m*is the mass (in kilograms), and*c*is 299,792,458 m/s. By the way, a petajoule is one quadrillion (10^{15}) joules. - Is
`first-guess`

a legal variable name in JavaScript? If not, why do you think such a name was banned? (Answer using complete sentences. Back up your answer. Concrete examples will most likely be helpful.) - Here is a script that determines how long it takes to grow $1000 into $5000 assuming an APR
(annual percentage rate) of 5%, compounded yearly:
var total = 1000; var year = 0; while (total < 5000) { year = year + 1; total = total * 1.05; } alert("It will take you " + year + " years to get there.");

Modify the script so that it first prompts for the APR and then computes the amount of time required to grow the $1000 to $5000 where the rate is compounded

*monthly*. You may alert the result in either months or years. - Write an expression that is true if and only if the value stored in variable
`x`is between 0 and 10 (inclusive). - Write a script that prompts for a string, then alerts whether or not the entered string
contains either a backslash character or a Telugu letter ddha (U+0C22). You should use
the
`indexOf`

operator on strings. Recall that`s.indexof(t)`

will return the first position (starting at 0) at which`t`appears, but returns a negative number if`t`is not found within`s`. - Evaluate the expression
`"dog".charAt(2).charAt(0)`

and explain the result. - Write a script that prompts for the abbreviation of a New England state and alerts the
capital of that state. The first line is:
var capitals = {ME: "Augusta", NH: "Concord", VT: "Montpelier", MA: "Boston", CT: "Hartford", RI: "Providence"};

Therefore, if your user inputs NH, your script should alert Concord. If you want a point of extra credit, allow the user to enter data in any case, for example NH, Nh, nH, or nh for New Hampshire. - Draw a picture of the objects resulting from the following declaration:
var p1 = {name: "Alice"}; var p2 = {name: "Bob", manager: p1}; p1.manager = p1;

What is the value of`p2.manager.manager.manager.name`

? - Draw a picture of the array referred to by the variable
`a`

after executing the following:var a = [1,2,3,4]; a.unshift(a.pop()); a.concat([5, 6, 7]);

- Define a prototype guitar and three guitars based on that
prototype as follows:
- The prototype is six-stringed, steel-string, right-handed, acoustic, mahogany.
- The first guitar is six-stringed, steel-string, left-handed, electric, mahogany, Fender.
- The second guitar is twleve-stringed, steel-string, right-handed, electric, mahogany, 1953 Les Paul signed by Billie Joe Armstrong.
- The third guitar is a six-string, nylon-string, right-handed, acoustic, 1976 Gibson Explorer Limited Edition of unknown composition, owned by The Edge.

- Draw a picture representing the following collection of
variables and their values:
var character = {real: true, gender: "female"}; var alice = Object.create(character); alice.name = "Alice"; alice.next = Object.create(character); alice.next.name = "Tweedledee"; alice.next.real = false; alice.next.gender = "male"; alice.next.next = Object.create(character); alice.next.next.real = false; alice.next.next.name = "Red Queen"; alice.next.next.next = alice;

- Write a script that prompts for two strings and then alerts whether one string is a substring
of the other. Do
**not**use an if statement. - Write a script that reads the content of the HTML textbox with the ID of "message"
and then writes into the HTML element with ID "shuffled" the value of the original string
with its two halves swapped. Here are several examples of swapping halves:
"" ⇒ "" "it" ⇒ "ti" "lizard" ⇒ "ardliz" "this laptop is lame" ⇒ "op is lamethis lapt"

- Write a JavaScript function called
`dollarMessage`

that has one parameter representing a number of dollars and returns a string stating how many dollars this is. Here are some test cases:dollarMessage(5) ⇒ "5 dollars" dollarMessage(1) ⇒ "1 dollar" dollarMessage(7.244) ⇒ "7.244 dollars"

Use a conditional expression, not an if-statement, to distinguish between writing "dollar" versus "dollars". - Write a JavaScript function called
`isNonnegativeAndFinite`

that takes a single parameter and returns whether or not its value, when**interpreted as a number**, is nonnegative and finite. - Write a function called
`sign`

that takes one parameter, a number, and returns -1 if the number is negative, 0 if the number is 0, 1 if the number is positive, and NaN if the parameter is not a number. Use an if-statement. - Write a function called
`isSmallInteger`

which returns`true`

if its sole parameter is an integer between -128 and 127, inclusive, and`false`

otherwise. Your function body should have a single return statement in which you test that your parameter is not NaN, not a floating point number (you can use the remainder when divided by 1 idiom), greater than or equal to -128 and less than or equal to 127.isSmallInteger("dog") ⇒ false isSmallInteger(-129) ⇒ false isSmallInteger(-128) ⇒ true isSmallInteger(127) ⇒ true isSmallInteger(128) ⇒ false isSmallInteger(14.8) ⇒ false isSmallInteger(14.0) ⇒ true

- Write a function called
`sumOfRange`

that takes in two parameters,`x`and`y`, which should both be small integers (see the previous problem), and returns the sum of all of the integers in the range from`x`(inclusive) to`y`(exclusive). If either of`x`or`y`is not a small integer (call the function from the previous problem to check this!!!) then throw an exception. Example test cases for you:sumOfRange(5, 9) ⇒ 5 + 6 + 7 + 8 = 26 sumOfRange(-2, 4) ⇒ -2 + -1 + 0 + 1 + 2 + 3 = 3 sumOfRange(9, 5) ⇒ 0 (because there are no numbers >=9 AND <5) sumOfRange(-99999, 0) ⇒

*throws an exception*sumOfRange(14, "dog") ⇒*throws an exception* - Write a function called
`sumOfEvensInRange`

that takes in two parameters, x and y, which should both be short integers (see the previous problem), and returns the sum of all of the*even*integers in the range from x (inclusive) to y (exclusive). If either of x or y is not a short integer (call the function from the previous problem to check this!!!) then throw an exception. Example test cases for you:sumOfEvensInRange(5, 9) ⇒ 6 + 8 = 14 sumOfEvensInRange(-2, 4) ⇒ -2 + 0 + 2 = 0 sumOfEvensInRange(9, 5) ⇒ 0 (because there are no numbers >=9 AND <5) sumOfEvensInRange(-99999, 0) ⇒

*throws an exception*sumOfEvensInRange(14, "dog") ⇒*throws an exception* - Write a function called
`sumOfCodepoints`

which takes a string and returns the sum of each of the codepoints in the string. - Write a function with no parameters that returns a two-element array containing two (possibly different) dice rolls.
- Write a function that returns a two-element array
containing two (possibly different) dice rolls for an N-sided die. You
should read the phrase "N-sided" die as implying that
**N should be a parameter of your function**. - Write a function called
`withoutMiddleThird`

which takes a string and returns the string that is like its argument but without its "middle third" characters. Examples:withoutMiddleThird("ABCDEFGHI") ⇒ "ABCGHI" withoutMiddleThird("") ⇒ "" withoutMiddleThird("a") ⇒ "a" withoutMiddleThird("ab") ⇒ "b" withoutMiddleThird("abc") ⇒ "ac"

- Write a function called
`squares`

that takes in an array and returns a NEW array containing all the squares of the input array. Test cases:squares([1,7,-4]) ⇒ [1,49,16] squares([]) ⇒ [] squares([true, -6, null]) ⇒ [1, 36, 0]

- Write a function called
`square`

that takes in an array of numbers and CHANGES THIS ARRAY by replacing each element with its square. Test cases:var a = [1,7,-4]; square(a); a ⇒ [1,49,16]

- Write a function called
`chomped`

that takes in an array and returns a NEW array containing all the values of the input array, interpreted as strings, with their last characters removed. Test cases:chomped(["one", "two", "three"]) ⇒ ["on", "tw", "thre"] chomped([]) ⇒ [] chomped([true, -6, null]) ⇒ ["tru", "-", "nul"]

- Write a function
called
`chompAll`

that takes in an array and CHANGES THIS ARRAY by replacing each element with its chompedness. The description of chomping can be gleaned from reading the description in the previous problem. Test cases:var a = ["one", "two", "three"]; chompAll(a); a ⇒ ["on", "tw", "thre"]

- Write a function that takes in one parameter and returns how many times
you have to cut it in half to produce a value less than or equal to 1.
Note that if the number is already 1 or less, you should immediately
return 0. Use a while statement or a do-while statement. Some test
cases for you:
halfsies(1) ⇒ 0 halfsies(0) ⇒ 0 halfsies(-22.7) ⇒ 0 halfsies(2) ⇒ 1 halfsies(19) ⇒ 5 halfsies(7.225E102) ⇒ 342

- You're working with a team of programmers and you need a factorial function. (The factorial
of a positive integer n is the product 1 * 2 * ... * n, with the factorial of all values less than
or equal to 1 being taken as 1.) Someone on your team gives you this:
var product = 1; // Returns the factorial of n. Precondition: n is a positive // integer <= 18. var factorial = function (n) { for (var i = 2; i <= n; i += 1) { product *= i; } return product; }

Naturally, you are extremely disappointed in your co-worker's solution. Why is it so bad? (For full credit, don't just say "Because it doesn't work." Give an explanation that shows you understand the defect in the code.) - What is alerted in the following script and why?
var x = 20; var f = function (y) {alert(x / y); y = 3;} f(8); alert(y);

- Here is an attempt to write a script that computes the sum
of the numbers from 1 to 10000, inclusive. However, there are three
major problems. Identify the mistakes and explain how to correct them.
(Note: find actual programming mistakes, not mistakes of style; do not
pick on the names, the indentation, the formatting, or the lack of
comments.)
var sum; for (int i = 1; i < 10000; i++) { sum += i; alert("The sum from 1 to 10000 is " + sum); }

- Write a script that asks the user for a string
via
`prompt`

, then displays the Fuddified version of the string with`alert`

. (The Fuddified version of a string is the string with all r's and l's replaced with w's.) - Write a function that accepts a non-negative integer between 1
and 10000 inclusive and returns
the length of the Collatz sequence starting at that value. Throw an
exception if the argument isn't desirable.
lengthOfCollatzSequence(1) ⇒ 1 lengthOfCollatzSequence(3) ⇒ 8 lengthOfCollatzSequence(4) ⇒ 3 lengthOfCollatzSequence(16) ⇒ 5

- Write a function to determine whether a given year is a leap
year or not. Throw an exception if the year is
earlier than 1582. Note: A year is a leap year if it is divisible
by 4, but not 100, unless also by 400.
isLeapYear(2000) ⇒ true isLeapYear(1940) ⇒ true isLeapYear(2100) ⇒ false isLeapYear(1987) ⇒ false isLeapYear(1381) ⇒

*(throws an exception)* - Write a function that takes in an object with an
`x`property and a`y`property, and returns the quadrant of the point. In case you didn't know, Quadrant 1 contains points with non-negative x and non-negative y; quadrant 2 has points with negative x and non-negative y; in quadrant three both x and y are negative; quadrant 4 has non-negative x and negative y. - Write a function that takes in a string s and returns
the string which is equivalent to s but with all ASCII vowels
removed. (ASCII characters are those Unicode characters whose
codepoints are in the range 0..127 inclusive.)
stripVowels("Hello, world") ⇒ "Hll, wrld"

- Write a function that
*randomly*permutes a string. By random we mean that each time you call the method for a given argument all possible permutations are equally likely (note that "random" is not the same as "arbitrary.") For example:scramble("Hello, world") ⇒ "w,dlroH elol"

- Write a function that produces powers of two starting
at 1 and going up to some limit.
powersOfTwo(70) ⇒ [1,2,4,8,16,32,64]

- What is alerted in the following script?
var x = 1; var f = function (y) {alert(x + y);} f(2);

What would happen if the parameter`y`were renamed to`x`? - Write a function that doubles up each item in an array. Here are
test cases your function should satisfy:
stutter([5,true,[3],"ha"]) ⇒ [5,5,true,true,[3],[3],"ha","ha"] stutter([{}, null]) ⇒ [{}, {}, null, null]

- Write a function that takes in a point object, that is, an object with an x property and a y property, and returns the quadrant of the point. In case you didn't know, Quadrant 1 contains points with non-negative x and non-negative y; quadrant 2 has points with negative x and non-negative y; in quadrant three both x and y are negative; quadrant 4 has non-negative x and negative y.
- Write a script that produces an array with successive
prefixes of argument, starting with the first
prefix, which is zero characters long. For example:
prefixes("eich") ⇒ ["", "e", "ei", "eic", "eich"] prefixes("") ⇒ [""]

- Write a function that produces an array with successive
suffixes of its argument, starting with the first
suffix, which is zero characters long. For example:
suffixes("eich") ⇒ ["", "h", "ch", "ich", "eich"] suffixes("") ⇒ [""]

- Write a function that removes "every nth character" of string. That is, given a
string
`s`and a positive integer`n`return the string like`s`but with characters at positions 0, n, 2n, 3n, and so on, removed. Throw an exception if`n`is not a positive integer.sift("javascript", 2) ⇒ "aacit" sift("python", -4) ⇒

*throws an exception*sift("coffeescript", 5) ⇒ "offescrit" sift("java", alert) ⇒*throws an exception* - Write a function that produces an array of powers of an arbitrary
base starting at exponent 0 and going up to some limit. Throw an
exception if the base is less than or equal to 1.
powers(3, 400) ⇒ [1,3,9,27,81,243] powers(-2, 17) ⇒

*throws an exception*powers(3, -9) ⇒ [] powers(0.5, 22) ⇒*throws an exception* - Write a function that interleaves two arrays. If the arrays do not
have the same length, the elements of the longer array should end
up at the end of the result array.
interleave(["a", "b"], [1, 2, true, nil]) ⇒ ["a", 1, "b", 2, true, nil] interleave(["a", "b"], []) ⇒ ["a", "b"]

- Write a function that takes in an array of arrays and returns whether
or not the argument is a
*square matrix*. A square matrix is an array with n elements, each of which is an n-element array. - Suppose we have a bunch of objects representing people. Each object has three properties (at least): name, mother, and father. The value of the name property is a string, and the values of the mother and father properties are either other people objects, or are null. Write a function that takes in a person object and returns the array of all of the person's (known) grandparents. Hint: the resulting array will have either 0, 1, 2, 3, or 4 values.
- Write a function that takes in two people objects (defined in the previous problem) and returns whether or not they are (known for sure to be) first cousins.
- Write a function that takes in a string and produces an object
as follows. The string is made up of a number of "pairs" separated
by "|" characters. Each pair has its two components separated internally
with commas. You need to create a real JavaScript object from the string
by treating each pair as a property name together with its value. If that
was hard to understand, just "figure it out" from the following examples:
objectify("a,dog|b,cat|z,rat") ⇒ {a: "dog", b: "cat", z: "rat"} objectify("") ⇒ {} objectify("one,uno|two,dos") ⇒ {one: "uno", two: "dos"}

- Suppose you were asked to write a function to take in an array
and swap the first and second elements of the array (that's right:
actually change the array that was passed in!). You could write:
var swapFirstTwoElementsOf = function (a) { var oldFirstElement = a[0]; a[0] = a[1]; a[1] = oldFirstElement; }

This works. Then your friend comes along and says "oh hang on, I can do better" and writes this:var swapFirstTwoElementsOf = function (a) { a = [a[1],a[0]].concat(a.slice(2, a.length)); }

Does your friend's function work? Why or why not? Be very specific. Use precise, technical language. - Write a script (using Canvas) that draws 20 randomly placed squares, each 30 pixels wide. Make sure each square fits completely in the canvas. The squares can be any color you choose, with any degree of transparency you choose.
- What does the following script alert? Why? Illustrate your answer with pictures!
var x = 2; var f = function () {return this.x - 5;} var p = {x: 1, y: x, z: f}; alert(f === p.z); alert(f()); alert(p.z()); alert(p.y);

- Write a JavaScript function called
`take`

which takes an array`a`and a number`n`and returns a new array consisting of the first`n`elements of`a`. If`n`is greater than the length of`a`, return a copy of`a`. - Write a JavaScript function called
`drop`

which takes an array`a`and a number`n`and returns a new array consisting of all but the first`n`elements of`a`. If`n`is greater than the length of`a`, return an empty array. - Write a function that returns the first value in an array that meets
a given condition. By "first" we mean "counting from the left." By "condition"
we mean "a function returning a Boolean." For example:
first([4,3,9,2,10], function (x) {return x > 5}) ⇒ 9 first([Infinity, "dog", 8, NaN], isFinite) ⇒ 8