**Due**: Sunday, 22-Sept. at 8pm

**Rules**:

- Problems marked
**SOLO**may not be worked on with other classmates, though you may consult instructors for help. - For problems marked
**COLLABORATIVE**, you may work in groups of up to 3 students who are in this course this semester (and then with nobody else except the course instructors). You may not split up the work – everyone must work on every problem. And you may not simply copy any code but rather truly work together. - Even though you work collaboratively, you still must submit your own solutions.

**Instructions**:

Before beginning this assignment, be sure to have read the Getting Started, Programming Basics, and Functions lessons.

Open RStudio and create a new project called “hw2-lastName”, replacing “lastName” with your last name.

Download the hw2.R template script and place it in RStudio project folder you just created.

Fill out your name, GW Net ID, and the names of anyone you worked with in the header of the “hw2.R” file.

Type all of your answers to the questions below in the “hw2.R” script.

After completing the questions, create a zip file of all files in your R project folder for this assignment.

Submit the zip file on Blackboard by the due deadline.

**Write solutions to the following functions in your “hw2.R”
script.**

Rules:

- You may
**NOT**use loops on any of these functions. - For functions 1-7, you may
**NOT**use loops or conditionals

**Hint**: Read the Getting Started Tips, Programming Basics Tips, and
Functions Tips - these could come
in handy!

`integerSquareRoot(n)`

[SOLO, 5 pts]Given a non-negative integer `n`

, return the integer value
that is closest to its square root. For example,
`integerSquareRoot(10)`

returns `3`

.

`fabricYards(inches)`

[SOLO, 5 pts]Fabric must be purchased in whole yards. Write a function that takes
a non-negative number of inches of fabric desired, and returns the
smallest number of whole yards of fabric that must be purchased. Thus,
`fabricYards(1)`

is `1`

(you need a full yard if
you buy one inch) and `fabricYards(36)`

is also
`1`

, but `fabricYards(37)`

is `2`

.
Hint: There are 36 inches in a yard!

`fabricExcess(inches)`

[SOLO, 5 pts]Write a function that takes a non-negative number of inches of fabric
desired and returns the number of inches of excess fabric that must be
purchased (as purchases must be in whole yards). Thus, since you need a
whole yard when you buy 1 inch, `fabricExcess(1)`

is
`35`

. Similarly, `fabricExcess(36)`

is
`0`

, and `fabricExcess(37)`

is
`35`

.

Hint: there are (at least) two good ways to write this. One way
involves a simple expression using one of the math operators we have
learned. The other way uses `fabricYards(inches)`

(which you
just wrote!).

`distance(x1, y1, x2, y2)`

[COLLABORATIVE, 10
pts]Given four numeric values representing the points
`(x1, y1)`

and `(x2, y2)`

, write the function
`distance(x1, y1, x2, y2)`

returns the Euclidean
distance between those points.

`isRightTriangle(x1, y1, x2, y2, x3, y3)`

[COLLABORATIVE, 10 pts]Given six numeric values representing the points
`(x1, y1)`

, `(x2, y2)`

, and `(x3, y3)`

,
return `TRUE`

if the triangle formed by connecting the 3
points is a right triangle, and `FALSE`

otherwise. You may
wish to use the `distance(x1, y1, x2, y2)`

function as a
helper function. You may ignore the case where the 3 points are
collinear (and so do not form a triangle). Hint: Pythagorean
theorem.

`triangleArea(x1, y1, x2, y2, x3, y3)`

[COLLABORATIVE,
10 pts]Given six numeric values representing the points
`(x1, y1)`

, `(x2, y2)`

, and `(x3, y3)`

,
return the area of the triangle formed by connecting the 3 points. You
may wish to use the `distance(x1, y1, x2, y2)`

function as a
helper function. You may ignore the case where the 3 points are
collinear (and so do not form a triangle). Hint: Heron’s
Formula.

`numberOfPoolBalls(rows)`

[COLLABORATIVE, 10 pts]Pool balls are arranged in rows where the first row contains 1 pool
ball and each row contains 1 more pool ball than the previous row. Thus,
for example, 3 rows contain 6 total pool balls (1+2+3). With this in
mind, write the function `numberOfPoolBalls(rows)`

that takes
a non-negative integer value (the number of rows) and returns another
integer value (the number of pool balls in that number of full rows).
For example, `numberOfPoolBalls(3)`

returns `6`

.
We will not limit our analysis to a “rack” of 15 balls; rather, our pool
table can contain an unlimited number of rows. Do not use loops. Hint:
For this problem you should research Triangular
Numbers.

`isEvenPositiveInt(x)`

[COLLABORATIVE, 15 pts]Given an arbitrary value `x`

, return `TRUE`

if
it is an integer, and it is positive, and it is even (all 3 must be
true), or `FALSE`

otherwise. If the value `x`

is
not an integer, the function should return `FALSE`

rather
than error. So, `isEvenPositiveInt("yikes!")`

returns
`FALSE`

, and `isEvenPositiveInt(123456)`

returns
`TRUE`

. For this problem, consider integer *values* to
be “integers”. So, both `3`

and `3L`

are to be
considered integers, even though R will return `FALSE`

if you
type `is.integer(3)`

, since `3`

is technically a
“double”. **Hint**: Read the Programming Basics Tips.

`getTheCents(n)`

[COLLABORATIVE, 15 pts]Write the function `getTheCents(n)`

which takes a value
`n`

that represents a payment in US dollars and returns the
number of cents in the payment. For example, if `n`

is
`2.45`

, the function should return `45`

. If
`n`

is an integer, the function should return `0`

,
as it has `0`

cents; if it isn’t a number, it should return
`NULL`

, because a non-number payment make no cents (ha!). If
the payment has partial cents (for example, `3.953`

), it
should be rounded to the nearest cent (in this case, `95`

cents).

`turtleSquare(s)`

[COLLABORATIVE, 15 pts]Write the function `turtleSquare(s)`

which uses the
`TurtleGraphics`

library to draw a square with side length
`s < 100`

(because the turtle will “escape” the terrarium
when `s >= 100`

). The square should be centered in the
turtle’s terrarium. **Note**: Do not put the
`turtle_init()`

command inside your function - the turtle
must be “initialized” inside the terrarium before calling your
`turtleSquare(s)`

function. You should call your
`turtleSquare(s)`

function inside the
`turtle_do({})`

call as described in the TurtleGraphics lesson. For example, the
code below produces a square with side length of 50:

```
library(TurtleGraphics)
turtle_init()
turtle_do({
turtleSquare(50)
})
```

`numberOfPoolBallRows(balls)`

[SOLO, 5
pts]This problem is the inverse of the
`numberOfPoolBalls(rows)`

problem. In this case, return the
number of rows required for the given number of pool balls. Thus,
`numberOfPoolBallRows(6)`

returns `3`

. Note that
if any balls must be in a row, then you count that row, and so
`numberOfPoolBallRows(7)`

returns `4`

(since the
4th row must have a single ball in it).

`turtleTriangle(s)`

[SOLO, 5 pts]Write the function `turtleTriangle(s)`

which uses the
`TurtleGraphics`

library to draw an equilateral triangle with
side length `s < 100`

. The triangle should be centered in
the turtle’s terrarium. Hint: Getting the triangle centered is the
tricky part - you may want to read more about equilateral
triangles and apothems. The code
below produces a triangle with side length of 50:

```
library(TurtleGraphics)
turtle_init()
turtle_do({
turtleTriangle(50)
})
```

George Washington University | School of Engineering & Applied Science

Dr. John Paul Helveston | jph@gwu.edu | Mondays | 6:10–8:40 PM | Phillips Hall 108 | |

This work is licensed under a Creative Commons Attribution 4.0 International License.

See the licensing page for more details about copyright information.

Content 2019 John Paul Helveston