Check the validity of a 10-digit telephone number

Question

Your task is to write a program or function that checks if a string is a valid phone number.

Given a string (or list of characters/codepoints) input, you will output a truthy value if the input is a valid phone number. If it is not, output a falsey value. An input string is considered a valid phone number for this challenge if it meets all of these criteria:

• It contains ten digits, which are grouped like this: ###-###-####
• The strings separating the digit groups must be the same
• The first and last characters must be part of the phone number (i.e. must not be part of a separator)

Test cases:

111-222-3333     truthy
123-456-7890     truthy (number groups can contain different numbers)
1112223333       truthy (can have 0 length separators)
111022203333     falsey (has more than 10 numbers)
111ABC222ABC3333 truthy (can have length>1 separators)
111-222_3333     falsey (non-matching separators)
111-22-23333     falsey (missing digit in middle group)
111--222--33333  falsey (extra digit in last group)
-111-222-3333    falsey (first character is not part of number)
111-222-3333a    falsey (last character is not part of number)
aaa-aaa-aaaa     falsey (not enough numbers)
11-2222-3333     falsey (wrong separator location)
111-1-222-1-3333 falsey (too many numbers)

This is a code golf challenge, shortest answer per language wins.

Answer 1

Jelly, 22 bytes

fØDȯ0ṁ334DR¤jḟØDŒHḢƊµƑ

A monadic Link accepting a list of characters which yields 1 if it is a valid telephone number and 0 otherwise.

Try it online! Or see a test-suite.

How?

fØDȯ0ṁ334DR¤jḟØDŒHḢƊµƑ - Link: list of characters, S  e.g. '123a456bc78de'
                     Ƒ - is S invariant under...
                    µ  - ...this function of S?:
f                      -   filter keep:
 ØD                    -     digit characters              '12345678'
   ȯ0                  -   OR zero (necessary as ṁ will error with an empty list)
           ¤           -   nilad followed by link(s) as a nilad:
      334              -     literal 334                   334
         D             -     to decimal                    [3,3,4]
          R            -     range (vectorises)            [[1,2,3],[1,2,3],[1,2,3,4]]
     ṁ                 -   mould (left) like (right)       ['123','456','7812']
                   Ɗ   -   last three links as a monad  - i.e. f(S):
             ḟ         -     filter discard:
              ØD       -       digit characters           'abcde'
                ŒH     -     split in halves              ['abc', 'de']
                  Ḣ    -     head (zero if empty)         'abc'
            j          -   join                           '123abc456abc7812'
                                                  (...not invariant as not equal to S)

Answer 2

Perl, 36 bytes

print/^\d{3}(\D*)\d{3}\1\d{4}$/?1:0

Run as

perl -ne 'print/^\d{3}(\D*)\d{3}\1\d{4}$/?1:0' <<< "111-222-3333"

Try it online!

Answer 3

APL (Dyalog Unicode), 30 29 bytes^SBCS

'^\d{3}(\D*)\d{3}\1\d{4}$'⎕S⍬

It simply ⎕Searches for the PCRE regex and returns a dummy value (the empty numeric list) for each match. If none are found, it returns a single empty numeric list.

Try it online! The effect of printing a list of empty lists is to print two spaces on a line, while the effect of printing an empty list is to print an empty line. Select all contents in the Output field to reveal the spaces, or use this to lead each printed line with → and each space with ·.

Answer 4

05AB1E, 16 bytes

þ©м2äн®T∍ƵêS£sýQ

Port of @JonathanAllan's Jelly answer.
Thanks to @Grimy for fixing a bug.

Try it online or verify all test cases.

Explanation:

þ                 # Only leave the digits of the (implicit) input-string
 ©                # Store it in variable `®` (without popping)
  м               # Remove all digits from the (implicit) input-string
   2ä             # Split the remaining characters into two equal-sized parts
     н            # And only leave the first part
      ®           # Push the digits from variable `®` again
       T∍         # Extend this string of digits to size 10
         Ƶê       # Push compressed integer 334
           S      # Converted to a list of digits: [3,3,4]
            £     # And split the digits of the input into parts of that size
             s    # Swap to get the earlier string
              ý   # And join the digit-parts with this delimiter-string
               Q  # Check if it's now equal to the (implicit) input-string
                  # (after which the result is output implicitly)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why Ƶê is 334.

Answer 5

PHP, 50 bytes

Just a simple regex, with a backreference to make sure the separator is the same.

<?=preg_match('/^\d{3}(\D*)\d{3}\1\d{4}$/',$argn);

Try it online!

Answer 6

JavaScript (ES6), 37 bytes

s=>/^\d{3}(\D*)\d{3}\1\d{4}$/.test(s)

Try it online!

Answer 7

Gema, 26 characters

<D3><-d><D3>$2<D4>\Z=t
*=f

There is no truthy / falsey concept in Gema, so just outputting “t” / “f”.

Sample run:

bash-5.0$ echo -n 111-222-3333 | gema '<D3><-d><D3>$2<D4>\Z=t;*=f'
t

Try it online! / Try all test cases online!

Answer 8

Ruby -n, 28 bytes

Same as basically every other regex solution here. Note that in Ruby, 0 is actually truthy. (Only false and nil are falsey in Ruby)

p~/^\d{3}(\D*)\d{3}\1\d{4}$/

Try it online!

Answer 9

Red, 64 bytes

func[s][d: charset[#"0"-#"9"]parse s[3 d copy t to d 3 d t 4 d]]

Try it online!

As always Red's parse is much longer than regex.

Answer 10

Python 3, 69 66 57 bytes

lambda n:re.match(r"\d{3}(\D*)\d{3}\1\d{4}$",n)
import re

Try it online!

Thanks To:
-@Arnauld and @Value Ink for saving me 3 bytes by using match instead of fullmatch
-@Value Ink for saving me another 6 bytes

Answer 11

Java (JDK), 43 bytes

s->s.matches("\\d{3}(\\D*)\\d{3}\\1\\d{4}")

Try it online!

Apparently I came to the same solution as others: a simple regex is the key.

Answer 12

Retina 0.8.2, 24

Same regex as the other regex-based answers:

^\d{3}(\D*)\d{3}\1\d{4}$

Try it online!

Answer 13

Kotlin (JDK), 60 bytes

{s: String->s.matches(Regex("\\d{3}(\\D*)\\d{3}\\1\\d{4}"))}

Try it online!

Really similar to the Java one

Answer 14

Clojure, 46 bytes

(fn[x](re-matches #"\d{3}(\D*)\d{3}\1\d{4}"x))

Try it online!

Another day, another regex.

Answer 15

SimpleTemplate, 56 bytes

This was actually a very simple challenge, using XMark's RegEx in the PHP answer.

{@ifargv.0 is matches"@^\\d{3}(\\D*)\\d{3}\\1\\d{4}$@"}1

Sadly, due to the need to escape the slashes, this code is 5 bytes longer :/

This code outputs 1 in case the input matches (truthy), or nothing (falsy).

You can try the golfed and ungolfed versions in http://sandbox.onlinephpfunctions.com/code/ca206ad7cc82351283e6c319ce5f9ae03f87b695
You can also check the generated PHP code, if you are curious.

Answer 16

QuadS, 28 25 bytes^SBCS

^\d{3}(\D*)\d{3}\1\d{4}$

It simply ⎕Searches for the PCRE regex and returns a dummy value (the empty string) for each match. If none are found, it returns a single empty numeric list.

Try it online! The effect of printing a list of empty strings is to print two spaces on a line, while the effect of printing an empty list is to print an empty line. Select all contents in the Output field to reveal the spaces, or use this to lead the printed line with → and each space with ·.