0
1
0
1

# helenst's solution

## to Phone Number in the Scala Track

Instructions
Test suite
Solution

Clean up user-entered phone numbers so that they can be sent SMS messages.

The North American Numbering Plan (NANP) is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda. All NANP-countries share the same international country code: `1`.

NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as area code, followed by a seven-digit local number. The first three digits of the local number represent the exchange code, followed by the unique four-digit number which is the subscriber number.

The format is usually represented as

``````(NXX)-NXX-XXXX
``````

where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.

Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code (1) if present.

For example, the inputs

• `+1 (613)-995-0253`
• `613-995-0253`
• `1 613 995 0253`
• `613.995.0253`

should all produce the output

`6139950253`

Note: As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.

## Hints

For simplicity and readability: Consider using the Scala collection functions instead of Java's `String` methods. Remember that in Scala a `String` is implicitly also a `Seq[Char]`, so you can call them as easily as the `String` methods.

Some examples:

• `filter` instead of `replaceAll`
• `take`, `takeRight`, `drop`, `head`, `tail` instead of `substring`

Another idea worth exploring might be to change the `String` into a `List[Char]` and then use pattern matching with the `::` operator.

The Scala exercises assume an SBT project scheme. The exercise solution source should be placed within the exercise directory/src/main/scala. The exercise unit tests can be found within the exercise directory/src/test/scala.

To run the tests simply run the command `sbt test` in the exercise directory.

For more detailed info about the Scala track see the help page.

## Source

Event Manager by JumpstartLab http://tutorials.jumpstartlab.com/projects/eventmanager.html

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

### PhoneNumberTest.scala

``````import org.scalatest.{Matchers, FunSuite}

/** @version 1.4.0 */
class PhoneNumberTest extends FunSuite with Matchers {

test("cleans the number") {
PhoneNumber.clean("(223) 456-7890") should be(Some("2234567890"))
}

test("cleans numbers with dots") {
pending
PhoneNumber.clean("223.456.7890") should be(Some("2234567890"))
}

test("cleans numbers with multiple spaces") {
pending
PhoneNumber.clean("223 456   7890   ") should be(Some("2234567890"))
}

test("invalid when 9 digits") {
pending
PhoneNumber.clean("123456789") should be(None)
}

pending
PhoneNumber.clean("22234567890") should be(None)
}

test("valid when 11 digits and starting with 1") {
pending
PhoneNumber.clean("12234567890") should be(Some("2234567890"))
}

test("valid when 11 digits and starting with 1 even with punctuation") {
pending
PhoneNumber.clean("+1 (223) 456-7890") should be(Some("2234567890"))
}

test("invalid when more than 11 digits") {
pending
PhoneNumber.clean("321234567890") should be(None)
}

test("invalid with letters") {
pending
PhoneNumber.clean("123-abc-7890") should be(None)
}

test("invalid with punctuations") {
pending
PhoneNumber.clean("123-@:!-7890") should be(None)
}

test("invalid if area code starts with 0") {
pending
PhoneNumber.clean("(023) 456-7890") should be(None)
}

test("invalid if area code starts with 1") {
pending
PhoneNumber.clean("(123) 456-7890") should be(None)
}

test("invalid if exchange code starts with 0") {
pending
PhoneNumber.clean("(223) 056-7890") should be(None)
}

test("invalid if exchange code starts with 1") {
pending
PhoneNumber.clean("(223) 156-7890") should be(None)
}
}``````
``````object PhoneNumber {
val Invalid = List("000", "000", "0000")
val ValidNumber = """1?(\d{3})(\d{3})(\d{4})""".r
}

class PhoneNumber(rawNumber: String) {
private val parts = rawNumber.filter(_ isDigit) match {
case PhoneNumber.ValidNumber(parts @ _*) => parts
case _ => PhoneNumber.Invalid
}

val number = parts.mkString("")
val areaCode = parts(0)

override def toString = "(%s) %s-%s".format(parts:_*)
}``````

### What can you learn from this solution?

A huge amount can be learnt from reading other people’s code. This is why we wanted to give exercism users the option of making their solutions public.

Here are some questions to help you reflect on this solution and learn the most from it.

• What compromises have been made?
• Are there new concepts here that I could read more about to develop my understanding?