[Question]
  [
In your grandparents' day, dialing a phone number was done with a [rotary dial](https://en.wikipedia.org/wiki/Rotary_dial) like this:
![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/7b/Rotarydial.JPG/220px-Rotarydial.JPG)
To dial each digit, put your finger in the corresponding hole, pull it over to the finger stop, and release it. A mechanism will cause the dial to spin back to its resting position, and the phone will disconnect and reconnect a circuit a specified number of times, making audible clicks.
Dialing the digit *N* requires *N* such “pulses”, except for N=0 which is ten pulses.
Rotary phones have the property that large digits (8, 9, 0) take longer to dial than small digits (1, 2, 3). This was an important consideration in drawing up early area code maps, and why New York City with its heavy population (and phone line) density got [212](https://en.wikipedia.org/wiki/Area_codes_212,_646,_and_332) (only 5 pulses), while while [907](https://en.wikipedia.org/wiki/Area_code_907) (26 pulses) went to sparsely-inhabited Alaska. Of course, this all became irrelevant when touch-tone dialing became popular.
# The challenge
Write, in as few bytes as possible, a program or function that takes as input a string (or sequence of characters) containing a telephone number, and outputs its number of rotary dial pulses. These are to be counted as follows:
## Digits
* Digits 1-9 count as that number of pulses.
* Digit 0 counts as 10 pulses.
## Letters
Note that digits 2-9 on the dial have letters of the Latin alphabet associated with them. These were originally intended for [named exchanges](https://en.wikipedia.org/wiki/Telephone_exchange_names), but were latter re-appropriated for [phonewords](https://en.wikipedia.org/wiki/Phoneword), and for text message input systems.
You must support having letters in your phone numbers, using the [E.161](https://en.wikipedia.org/wiki/E.161) assignment of letters to digits:
* A, B, C = 2
* D, E, F = 3
* G, H, I = 4
* J, K, L = 5
* M, N, O = 6
* P, Q, R, S = 7
* T, U, V = 8
* W, X, Y, Z = 9
You may assume that the input has already been case-folded, to either upper or lower case.
## Other characters
You **must** allow arbitrary use of the characters `()+-./` and space as formatting separators. You **may** chose to allow *any* non-alphanumeric character for this purpose, if it's easier to implement.
These characters do not contribute to the pulse count.
# Example code
A non-golfed lookup table and function in Python:
```
PULSES = {
    '1': 1,
    '2': 2, 'A': 2, 'B': 2, 'C': 2,
    '3': 3, 'D': 3, 'E': 3, 'F': 3,
    '4': 4, 'G': 4, 'H': 4, 'I': 4,
    '5': 5, 'J': 5, 'K': 5, 'L': 5,
    '6': 6, 'M': 6, 'N': 6, 'O': 6,
    '7': 7, 'P': 7, 'Q': 7, 'R': 7, 'S': 7,
    '8': 8, 'T': 8, 'U': 8, 'V': 8,
    '9': 9, 'W': 9, 'X': 9, 'Y': 9, 'Z': 9,
    '0': 10
}
def pulse_count(phone_num):
    return sum(PULSES.get(digit, 0) for digit in phone_num)
```
# Example input and output
* `911` → 11
* `867-5309` → 48
* `713 555 0123` → 42
* `+1 (212) PE6-5000` → 57
* `1-800-FLOWERS` → 69
* `PUZZLES` → 48
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~19~~ ~~18~~ ~~17~~ 15 bytes
```
AÁ0ªā6+žq÷9š‡þO
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f8XCjwaFVRxrNtI/uKzy83fLowkcNCw/v8///P1pJW0lHQckQRCiACA0QYQQXA7M04bIFICIVRJiBCF0QYQoiDJCIWAA "05AB1E – Try It Online")
This is the first answer to use π. Why use π, you might ask? Well, the letters are associated with 22233344455566677778889999, in order. Notice how most digits repeat 3 times, but 7 repeats 4 times. You could say that each digit repeats (3+1/7) times, on average. I wonder if there’s any number that’s approximately 3+1/7 and takes fewer bytes than 22/7…
This only gives 4 7s, not 4 9s, so we still need to handle Z as a special case.
```
A               # alphabet (abcdefghijklmnopqrstuvwxyz)
 Á              # rotate right (zabcdefghijklmnopqrstuvwxy)
  0ª            # append 0 (zabcdefghijklmnopqrstuvwxy0)
ā6+             # range [7..33]
   žq÷          # divide by π (22233344455566677778889991010)
      9š        # prepend 9 (922233344455566677778889991010)
‡               # transliterate the implicit input with the two lists above
                # this replaces z → 9, a → 2, … y → 9, 0 → 10
 þ              # remove all non-digits
  O             # sum
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 51 bytes
```
n=>n.Sum(x=>x>64?(x-59-x/83-x/90)/3:x>47?1-~x%~9:0)
```
Saved 1 byte thanks to @recursive
Saved 10 bytes thanks to @ExpiredData's observation that only `() +-/.` will be in the input
[Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU1xSlJmXrpOZV2KXZvs/z9YuTy@4NFejwtauws7MxF6jQtfUUrdC38IYSFgaaOobW1XYmZjbG@rWVajWWVoZaP635govyixJ9cnMS9VI01Ay1LUwMNB18/EPdw0KVtLURJO2NDQECf4HAA "C# (Visual C# Interactive Compiler) – Try It Online")
```
n =>                     // Function taking input as string
  n.Sum(x =>             // Map each value 'x' through the following
    x>64 ?               //   If 'x' is an uppercase letter
      (x-59-x/83-x/90)/3 //     Take each char's ASCII value subtracted by 59, and subtract
                         //     one if the char is 'S' and one if the char is 'Z'
    : x>47 ?             //   Else if the char is a digit
      1-~x%~9            //   Take 1 - (-x - 1) % -10 (Maps 0 to 10, and 1-9 to themselves
    : 0                  //   Else, 0
  )                      // And sum it all up, then return it
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 27 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function.
```
+/'@ADGJMPTW'∘⍸+11|(1⌽⎕D)∘⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X1tf3cHRxd3LNyAkXP1Rx4xHvTu0DQ1rNAwf9ex91DfVRRMstvl/2qO2CY96@4BCnv6PupoPrTd@1DYRyAsOcgaSIR6ewf/TFNQtDQ3VuYC0hZm5rqmxgSWYY25orGBqaqpgYGhkDBbQNlTQMDI00lQIcDXTNTUwMACLGupaGBjouvn4h7sGBasDAA "APL (Dyalog Unicode) – Try It Online")
`(`…`)∘⍳` find the **ɩ**ndex\* of each character in the following string:  
  \* elements that are not found, get the index 1+the maximum index, i.e. 11  
 `⎕D` the digits: `"0123456789"`
 `1⌽` cyclically rotate one step left; `"1234567890"`
`11|` division remainder when divided by 11\*  
  \* this gives 0 for all non-digits  
…`+` add that to the following:
 `'@ADGJMPTW'∘⍸` the **ɩ**nterval **ɩ**ndex\* for each character  
  \* So [−∞,"@") gives 0, ["@","A") gives 1, ["A","D") gives 2, etc.  
`+/` sum that
[Answer]
# [Python 2](https://docs.python.org/2/), 74 bytes
```
lambda s:sum([(n-59-n/83-n/90)/3,1-~n%~9][n<58]for n in map(ord,s)if n>47)
```
[Try it online!](https://tio.run/##FYhPC4IwHEDvfYofQrBBw801dVLd7BQUdYgwD4YNB/pz@Ifo4lc3uzzee@47VC0Gs9k/57poXmUBfdKPDckIMqUZ@rFcoDn15UawCdeTzjPcqTg3bQcIFqEpHGm7ctNTawAP24jOn8rWbxCJ6ywOYIhFNw6E0tnTQngrLw4jpiTXi0ZCglIKuAjkkgJIIAIKlzRkinP@XyzmnB1P53t6vS398H4 "Python 2 – Try It Online")
Does some arithmetic on the ASCII value for each character. The first option checks for letters and the second options checks for numbers. The clarification that all punctuation characters allowed in the input are ones with ASCII values less than 48 let me simplify the logic, but a new method altogether might now be better.
# [Python 2](https://docs.python.org/2/), 84 bytes
```
lambda s:sum(1+'1xxxx2ABCx3DEFx4GHIx5JKLx6MNOx7PQRS8TUVx9WXYZ0'.find(c)/5for c in s)
```
[Try it online!](https://tio.run/##FYjJDoIwFADvfsULF9sYtK9YFhMPLrgrCu7x4kZsopUIxvr1iHOameSb3Z6K53HzkN@Pj9PlCGkjfT8IVsqoC3ir3dFW1@/pen8w1GI0nmh7Ogu0M1@EkbtcrbW32e72rFyNpbqQM62J@PmCM0gFKc0/N3m/AjaSl1QZxESq5J0RSnPDQzRKhms7prCYV6iDFgghgCG3ikQgHDmFuW@bgjH2X6bLmNmbBBs/jIwf "Python 2 – Try It Online")
Uses a hardcoded lookup string, with each block of 5 characters corresponding to the characters giving each value starting with 1. Blank spaces are filled with `x`, which can't be in the input which is capitalized. Fortuitously, characters not appearing in the string produce `-1` for the `.find` which gives a summand of zero.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ... ~~76~~ 69 bytes
```
s=>s.replace(/\w/g,q=>w+=1/q?+q||10:parseInt(q,35)*.32-1|0||9,w=0)&&w
```
[Try it online!](https://tio.run/##dY1LSwMxFIX3/orQRUnMZPIymURJRbAWQdqiiA/cDGNalGFeKc4m/306bnXK5ZzF@T643/lPHoruqzmQqv70w84NwS1C2vmmzAsP6UdP90nrFj12nLbXuI2Rs8sm74K/rw6wTaRC56kUhEcWo016x9B83g9XRV2FuvRpWe/hDs4s5zOEzv7ORmdESWanWMYlUEoBxoWc4pgDKLhAYLvURDHGpiRODGPk7mHzsnx8Oi28vr3/wv8/jAYw0xaB2816RVbP6c2ajiagFBiscTbGYjm2xhfjGSywdpkajg "JavaScript (Node.js) – Try It Online")
-7 thanks @Arnauld!
### Explanation
```
 q |     1/q     |  +q  | parseInt(q,35)*.32 | parseInt(q,35)*.32-1|0 | Output
---+-------------+------+--------------------+------------------------+--------
 0 | Infinity(T) | 0(F) |         N/A        |           N/A          |   10
 1 |  1.0000(T)  | 1(T) |         N/A        |           N/A          |    1
 2 |  0.5000(T)  | 2(T) |         N/A        |           N/A          |    2
 3 |  0.3333(T)  | 3(T) |         N/A        |           N/A          |    3
 4 |  0.2500(T)  | 4(T) |         N/A        |           N/A          |    4
 5 |  0.2000(T)  | 5(T) |         N/A        |           N/A          |    5
 6 |  0.1666(T)  | 6(T) |         N/A        |           N/A          |    6
 7 |  0.1428(T)  | 7(T) |         N/A        |           N/A          |    7
 8 |  0.1250(T)  | 8(T) |         N/A        |           N/A          |    8
 9 |  0.1111(T)  | 9(T) |         N/A        |           N/A          |    9
 A |    NaN(F)   |  N/A |        3.20        |          2(T)          |    2
 B |    NaN(F)   |  N/A |        3.52        |          2(T)          |    2
 C |    NaN(F)   |  N/A |        3.84        |          2(T)          |    2
 D |    NaN(F)   |  N/A |        4.16        |          3(T)          |    3
 E |    NaN(F)   |  N/A |        4.48        |          3(T)          |    3
 F |    NaN(F)   |  N/A |        4.80        |          3(T)          |    3
 G |    NaN(F)   |  N/A |        5.12        |          4(T)          |    4
 H |    NaN(F)   |  N/A |        5.44        |          4(T)          |    4
 I |    NaN(F)   |  N/A |        5.76        |          4(T)          |    4
 J |    NaN(F)   |  N/A |        6.08        |          5(T)          |    5
 K |    NaN(F)   |  N/A |        6.40        |          5(T)          |    5
 L |    NaN(F)   |  N/A |        6.72        |          5(T)          |    5
 M |    NaN(F)   |  N/A |        7.04        |          6(T)          |    6
 N |    NaN(F)   |  N/A |        7.36        |          6(T)          |    6
 O |    NaN(F)   |  N/A |        7.68        |          6(T)          |    6
 P |    NaN(F)   |  N/A |        8.00        |          7(T)          |    7
 Q |    NaN(F)   |  N/A |        8.32        |          7(T)          |    7
 R |    NaN(F)   |  N/A |        8.64        |          7(T)          |    7
 S |    NaN(F)   |  N/A |        8.96        |          7(T)          |    7
 T |    NaN(F)   |  N/A |        9.28        |          8(T)          |    8
 U |    NaN(F)   |  N/A |        9.60        |          8(T)          |    8
 V |    NaN(F)   |  N/A |        9.92        |          8(T)          |    8
 W |    NaN(F)   |  N/A |       10.24        |          9(T)          |    9
 X |    NaN(F)   |  N/A |       10.56        |          9(T)          |    9
 Y |    NaN(F)   |  N/A |       10.88        |          9(T)          |    9
 Z |    NaN(F)   |  N/A |         NaN        |          0(F)          |    9
```
All of `[space]().+-/` are not captured by `/\w/g`, so they won't affect the total.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~52~~ 51 bytes
*@Grimy gets credit for -1*
```
y/A-Z/22233344455566677778889/;map$\+=$_||10,/./g}{
```
[Try it online!](https://tio.run/##K0gtyjH9/79S31E3St/IyMjY2NjExMTU1NTMzMwcCCwsLCz1rXMTC1RitG1V4mtqDA109PX002ur//@PMtQ1NPiXX1CSmZ9X/F/X11TPwNDgv24BAA "Perl 5 – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 39 bytes
```
1#.'?@CFILOSVZ'&I.+11|1+'1234567890'i.]
```
[Try it online!](https://tio.run/##RYxBC4JAFAbv/oqPgl5iu7yn7boKUhAKgmAkFASdoqW6dPBav33rlMeZgXkGP1YajBIcZK5ps901bdcPxzMtWp2IvCUhSbO1sbkrmB76EuJopkG@0oQVPiX8GEW36/0FDypE6A/O5spkXEwmlwzGGPBvOdlEsEwljbGvrTLMPCVRjlk1XX@qDwOFLw "J – Try It Online")
A port of [Adám's APL solution](https://codegolf.stackexchange.com/a/185999/75681) 
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 34 bytes
```
T`WTPMJGDA`Rd
}T`L`2L
0
55
\d
$*
1
```
[Try it online!](https://tio.run/##K0otycxL/K@qoeGe8D8kITwkwNfL3cUxISiFqzYkwSfByIfLgMvUlCsmhUtFi8vw/39LQ0MuCzNzXVNjA0suc0NjBVNTUwUDQyNjLm1DBQ0jQyNNhQBXM11TAwMDLkNdCwMDXTcf/3DXoGAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
T`WTPMJGDA`Rd
```
Convert the letters `WTPMJGDA` to the digits `9..0`.
```
}T`L`2L
```
Shuffle all the remaining letters down by 1 and repeat until all of the letters have been converted to digits.
```
0
55
```
Replace `0` with `55` as they take the same number of pulses to dial.
```
\d
$*
1
```
Take the digital sum.
[Answer]
# [K4](https://kx.com/download), 44 bytes
**Solution:**
```
+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?
```
**Examples:**
```
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"911"
11
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"867-5309"
48
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"+1 (212) PE6-5000"
57
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"1-800-FLOWERS"
69
```
**Explanation:**
Naive approach, likely pretty golfable. Lookup index of character, lookup score, sum.
```
+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")? / the solution
                                           ? / lookup
                          (               )  / do this together
                                       "0"   / string "0"
                                      ,      / join with
                                  .Q.n       / string "0123456789"
                                1_           / drop first
                               ,             / join with
                           .Q.A              / "A..Z"
  (                      )                   / do this together
                      !10                    / range 0..9
                     ,                       / join with
     (              )                        / do this together
               4 3 4                         / list (4;3;4)
              ,                              / join with
         (5#3)                               / list (3;3;3;3;3)
        &                                    / where, creates list 0 0 0 1 1 1 2 2 etc
      1+                                     / add 1
   1+                                        / add 1
+/                                           / sum up
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 53 bytes
```
{sum +<<m:g/\d/X||10}o{S:g[<:L>]=$/.ord*.313-28+|0+9}
```
[Try it online!](https://tio.run/##HcxNC4JAFIXhvb/iItJo0@i9DmNqFrSolVDUougDCcw2iWG0CPW3T0y7857F87q3z0jXXxhVMNfd@1MDz7I6fQSXMjj2PeHQdPv0cc7SfHGdO4HftOXYlyRFGPMeeTLo9@0LlesUHlRNa7GEiE0sFkdToSQmZk9JglIKkEJpmhO4IYUebFeRUIhoThIxoljnm8Nqt2czy7C2U0D3twfb6MCWzPfZic30Dw "Perl 6 – Try It Online")
Multiplies the ASCII code with 0.313 instead of 1/3 and uses bitwise OR which rounds to zero to get [the correct bias](https://tio.run/##K0gtyjH7/784sVJBKVlBQSEPiLX0jA2NFUBA18hCQbvGQEHbUsmaC6xGFw8AqknLL1JQd1TX01OPUleo5uIsKMrMK0nTUFItVlBQNUoBEmZ6xmkICixkmBKTp6SjoBKvw8XJqZdflKKjACLBzkBiAh2DygO6DENA21LTmqv2/38A).
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 94 89 86 80 bytes
Thanks to ceilingcat, nwellnhof and Rogem for the suggestions.
```
c;f(char*s){c=*s-48;s=*s?(c<10U?c?c:10:c-17<26U?(c-11-c/35-c/42)/3:0)+f(s+1):0;}
```
[Try it online!](https://tio.run/##bc/PS8MwFAfw@/6KR2GQNA3La9cfa1qHh3kSFGV4mDuUB60BrdLIPIz@68ZkePDgJe@bvPB5CcmByDnSPaOXbootP1MbW7mutPV1y6hBtd/SlmpUNUksm7TY@2OJKGmV5X5Zp3yV1YqLnlmBvFZ6dmb8hLfOjCyEbhoogeBDHPvNicN5ARBaRi986t8nZlqlQQjThNuaw8fk@z2LlhbaK1ia5zFKgnQ6mGMCPfuNnF@EC24PR2ghuo70X9MI4d8cbP@7y2D4H7eBtQEEmBezcxtEVxWlzDO1cSVmkOc5KEwzJxBYiimH@10hc6WUQ1kpJW9u7552D4/f1L92g3Xy6wc "C (gcc) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 256 bytes
You can replace the `(( … ))` constructs with `let` for identical byte count. There may be a good algorithm to reduce the case statements but not found it so far. With a bit of rework you could make it a function also (but not in same or less bytes unless you can discount the `function fname { … }` top and tail).
```
read p;while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; ([ABC) ((d+=2));; ([P-S]) ((d+=7));; ([W-Z]) ((d+=9));;([DEF]) ((d+=3));; ([GHI]) ((d+=4));; ([JKL]) ((d+=5));; ([MNO]) ((d+=6));; (?) d=$d; esac;p=${p#?};done;echo $d
```
[Try it online!](https://tio.run/##Nc9LC4JAFIbhfb/igC5mkIEzVnYZSrrYvZRaBEkLcwYMoiQXLcTfbkYz2@d7F@fckiKr67dKJOTik90fCgixSyuvxkipkC9Ik0KBXeZDHPIK7k8gMWeDK2066YzM0LSiWdA4Ry2T6UyTqyViJ1P1NJ3ZxdDgRySeBwsjbR0tV2tDHU2b7c5QV9P@EBry/uRTkCNbClBFkor8d7LlV81rTyVUmr3AlnXtcCAudylEgce6iNjirI/IFrvwHBxPXw "Bash – Try It Online")
A better solution using the map character technique makes use of the `tr` tool:
# [Bash with tr], 173 bytes
```
read p;p=$(echo $p|tr A-Z 22233344455566677778889999);while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; (?) d=$d; esac;p=${p#?}; done;echo $d
```
[Try it online!](https://tio.run/##NY69CsIwFEZ3n@KCGRJK4Cb9sW2oxUEnQdFBUBxqE6ggNrSCQ@2zx0jxG885w3er@sa5zlQarLIFoaZuWiD28@pgxc8gpQzDMIqiOI6TJFn4pWma@TH1bu4PA5SSYW7HJTKmdAt11Rsgg80xFyPcn0AvgmdX5jsdFH/hW@UN/rnAiZQMdEG0AtNX9e/PYOflqEC3T6Oma9q5QACVQjLYrxMeI@JM8BSRb7a70/pw/AI "Bash – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~33~~ 24 bytes
```
7r32:ØP«9Ṿ€ØAżFyfØDV€o⁵S
```
[Try it online!](https://tio.run/##AUMAvP9qZWxsef//N3IzMjrDmFDCqznhub7igqzDmEHFvEZ5ZsOYRFbigqxv4oG1U//Dh8WS4bmY//8xLTgwMC1GTE9XRVJT "Jelly – Try It Online")
A monadic link taking a string as its argument and returning the number of pulses. Rewritten inspired by [@Grimy’s 05AB1E answer](https://codegolf.stackexchange.com/a/186035/42248) so be sure to upvote them!
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell),109 102 87 bytes
```
$(switch -r($args|% t*y){\d{$_}[A-Y]{("{0}"-f(.313*$_-18))[0]}[Z]{9}0{10}})-join'+'|iex
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0WjuDyzJDlDQbdIQyWxKL24RlWhRKtSszompVolvjbaUTcytlpDqdqgVkk3TUPP2NBYSyVe19BCUzPaILY2Oiq22rLWoNrQoLZWUzcrPzNPXVu9JjO14v///@qGuhYGBrpuPv7hrkHB6gA "PowerShell – Try It Online")
EDIT: Used @mazzy's idea for a regex switch with some string formatting to cast char -> int -> string and grab only the first 'digit'
**Original:**
```
[char[]]"$args"|%{$a+=(48,(('22233344455566677778889999')[$_-65],(58,$_)[$_-ne48])[$_-lt64])[$_-gt47]-=48};$a
```
I was hoping to get <100 bytes, so I'll keep looking at it to see if there is anything else I can do. There's probably a way to remove the number string 
Sorry if this is confusing as I nested arrays with boolean indexing statements but -
**Explanation:** 
`[char[]]"$args"|%{` reads the input casted as a string and then explodes it to a char array and begins a for-each loop with checking `()[$_-gt47]` to see if any `()+-./` was entered (all have ascii character values <48)  
Note: Powershell accepts `$true` and `$false` as `1` and `0` respectively for array indices 
Then we get either `48` for the symbols, or:  
`('22233344455566677778889999'[$_-65],(58,$_)[$_-ne48])[$_-lt64]` 
The `[$_-lt64]` checks for a number or a letter (all assumed capital here). If it's a letter, `'22233344455566677778889999'[$_-65]` changes it to 0-25 to index into the array and output the pulse value (as a char). If the character is a number, we instead look at: `(58,$_)[$_-ne48]` checking for `0` and outputting `58` or just the numeric char itself. 
Around everything `$a+= ... -=48` initializes a numeric variable $a at `0` and then adds the output. The output is the ascii char value of a number, so subtract `48`. 
Note: if the input was a symbol, we get `$a+=48-48`, effectively ignoring it. If it was `0`, we get `$a+=58-48` to obtain our +10 
Lastly, `;$a` just outputs our final value post for-each loop
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~95~~ ~~85~~ 79 bytes
*inspired by [nwellnhof's answer](https://codegolf.stackexchange.com/a/186016/80745).*
*inspired by `[0]` from [Sinusoid's answer](https://codegolf.stackexchange.com/a/186776/80745).*
```
$(switch -r($args|% t*y){\d{$_}0{10}[A-Y]{"$(.313*$_-18)"[0]}Z{9}})-join'+'|iex
```
[Try it online!](https://tio.run/##TZFrT8IwFIa/71eckOJWupp2W3cxmog6vKEgiMiQEANTMERwmwEz9ttnHbrY99vzvL3kdLVch1E8CxeLHL3AEaQ50uL1PJnMgEYaeo5e420VktoXTp@mKRpnLOUsG9bpYJRWkLZvcrOGxpS7uDJkoyxIvSzD9G05f1eJup2HmzxTlGNNAbl0TfU4V3XgHP8B13aoMJknqeWW1OEmCCGAccP8MUZpCAfN4AaGtm9TwRiTWjil5tRljDaarb7f6Uple6Vq94Kg6Uv4756f8y1hO64H9ZPTM79xfnF5dd28uW217zrd@95D/3EQqLrGGeHEICaxiCA2cYhLPCBgEKOgZmGswoqiYRetXdwi3i4YKxi2UIW0eAOKdUDhZhVOknAqx4/GOxyF8ecikWBP/gqKCyjH/ctp@FFuwgdl@5DKakXJ8m8 "PowerShell – Try It Online")
Unrolled version:
```
$(
    switch -r($args|% toCharArray){
        \d    {$_}
        0     {10}
        [A-Y] {"$(.313*$_-18)"[0]}
        Z     {9}
    }
)-join '+'|Invoke-Expression
```
```
key .313*$_-18 "$(...)"[0]
--- ---------- -----------
  A      2.345 2
  B      2.658 2
  C      2.971 2
  D      3.284 3
  E      3.597 3
  F      3.910 3
  G      4.223 4
  H      4.536 4
  I      4.849 4
  J      5.162 5
  K      5.475 5
  L      5.788 5
  M      6.101 6
  N      6.414 6
  O      6.727 6
  P      7.040 7
  Q      7.353 7
  R      7.666 7
  S      7.979 7
  T      8.292 8
  U      8.605 8
  V      8.918 8
  W      9.231 9
  X      9.544 9
  Y      9.857 9
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 21 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
éT6T&\²|└t5φ╛│█♪√┘↑▓^
```
[Run and debug it](https://staxlang.xyz/#p=82543654265cfd7cc07435edbeb3db0dfbd918b25e&i=%22911%22%0A%22867-5309%22%0A%22713+555+0123%22%0A%22%2B1+%28212%29+PE6-5000%22%0A%221-800-FLOWERS%22&a=1&m=2)
[Answer]
# [Kotlin](https://kotlinlang.org), 113 bytes
```
{s:String->var t=0
for(c in s){val v=c-'0'
t+=when(v){0->10
in 1..9->v
in 17..42->(v-11-v/35-v/42)/3
else->0}}
t}
```
[Try it online!](https://tio.run/##jVjtbhu3Ev3vp5gaRb1CVrJkWXZkXAdwU6dN68ZpPpomfwp6l5L2erVUSa4V3cBAH@Tel@uL5J4ZcldaBwWaH6HIPeQM5@PM0LfGl0X1@fCQnlqtvM5pZiz5ReEoW6iy1NVcn@3h88L7lTs7PMxMruemnA2cV9mt/ggUIIPMLA//OBw9nkynY4Y/NXXlyRqv7IbyQpW0qkunHRUVKVotTKWpqpc32jI6KaqsrPOimlOpvdfW9fZ4/XlFG1NbmltV5StldeXdAeVqk8qZjI@HMTqcR2vlKOfz14Vf4PuuEmVxK1C@4JmIeGPCF62yBX7NC59CVR/kziABJ0Jnv5B9mbFWu5WpRNeFKTWjy5IKT@YOUG8aaNzrvFmlBPXJ6lIrpwEd0AUtNVuucEvGrgsckakaX7E7KIST3AqSb2BmnhTeMRTiPcteGVf4wlThbN4VjMpHMS4vXGaqSmc@Cm9nlBU2q6GwYpxb6ayYFXB8NJ@ZkS@W2qW0VLdiYTjmpgzXL4vs1g3EcN9FBwSFYTd6ASl/1AU0xE9XZwuG/fXnf4Pn//rzfykhXvTKS4y9OB/SelHA6og1rysGB2Q4/1Vwm9zK0ULdBdusrFlp6zeYKE@lsnMdrgsNHCWPU5qmNOyRV7eaSiM@8NHH2CJi3BKR3W4ZpXSU0rg3oDcc9hw@AVYsV8Z6hTiG7VyRa6vY4hwOuVVrvny9QuDYcsNwhCdsi/SA4VYu@GW92NALvab3xt7S0wJqc1DK4RC90OoONzS4djg54T3Bj7Ct7snNNGRj49x4OhodUWKqckOTaKteykYM3pEfNB2eUnJ00nynNZImBJOyTpebvkivFuqm4HS/KJW7VQO6nkH3Gog0ZL8KYXSjM7VEzFqO3ju2xXqhkQ4G7u17VjQm4g44XMgGN76Bz1omkZV3FoJTIQJHMxjnZuPhYUwQ045DLQ2hCVcj8ZeEYJnVVSYWEq@zb2VDUXGqhjj2lh2SAOwQhbrKNIcyRFuVBUaR/K28KqpAHB5X2mWi4DJTexzqGh9ts@JLMuOI0chZeF5IxcACbMWKDcuXM2Vp1pFovpNwk5/4F2Y06k/DBobL3bbymmTY2UDDgJbLj4adfLkKxCm/Xxivw3ExyI8gR6wXyYXTiYGRbSXp8e0KYQi3lCtEh2adnMkKrgqBpECnQC2ba6@1hY0tJFTw7wbeQBrnAcwZXiEYcmpKBDLiBs6STQh3iAVdSDCqFSe1LdryI05ZG5vHLJKSpD96BoOZnJrr6Hq3cV4vowXem5qWtcNqveLM5VvulBSOOGZ1Ca0dt0NI7RomuxyMTkZ88WJeLZE5DIZxmiOESdiiZ40jL1L6NqWndE5HjadSukzpGVbGceX7lH5I6TlWjuPKjyn9lNIVViZx5eeUXqR0jZWTuPIypV9SepXSayyexsU3Kb1N6VesPI4r71L6LaX3KX3A4nRrCLXha9TLGAh8uWCzBRNcCbLKNyFpkc8ZClMf4QrvpXxJDV/DQbAjx6IFka5DpWZgsPa1ILb51XWB4shHYoBkLGcNl7YQZHJKu4uS3qP@4FDcDIZC0kre2CUiJLKK02Au5Y1FvjU3yxaGa6Vp5FRylcpUfQleOFbbItvKabuaUGUsmIYpaIYUP3CgcFeEMgHKLzX7vSUvp3e1zQ2ESD0A3SCc9U7Bl2QM@Rl2X35UfJzUBFm4EA25e0Kgl8bconx4BcILUd5wXCHV5@XGI0hDnL18e/X6ksPgU3Q6HYwOzmiUttMjTFHFDi7i@G0cn8rYwsaYjrH8XRwv4/hMxhZ2jOkxlr@P4w9xfC5jC5tgOsHyj3H8KY5XMrawE0xPsPxzHF/E8VrGFnaK6SmWX8bxlzi@iuNrGVv4Y0xR7Q/exPFtHH@VsYVNMUVHcPAujr/F8X0cP8jYwods1iFP7/FfqL@Rin8X1yZCHb8jwnpnzS6rfW0r0M4yCZ4azLVPYjOJXoSDL7RIoKDt/k6QxFLWFqCGX2g6GlH/CY1GzcLjk9P@ZDyc8upxwwJ0OhrTZDKh4ehoLF8aOqJHI/QDo6Mevbw86U@GwyF/njSEghL0eDjsP7u6fnf56jV/Opk2n16@/fDh6vJ1FMSrz9o6DI74uGpaz1Itb3IVKgReApxAkmmO21ZwRsWFsUZtsGiHTT7YQ6xzec9A5kmo3Gf0WsbeGbp@j0DfI@KqqWeqLgN9eRRg6Yv/o61pCwM37gG7zfbQsMeeIG0kcecN5J2y8ahzGmLOhySdvWFfLyghR1/k/2ZW8wvdkcIEVEndQ5vZYO9UWWu@OqNjiaGlcR4lsmljixY94@K5yx0pluY1V1aulqDu7rlozSqt8wcPtagRbNKgVZ6z7QM9hfsO5BuOiUedb3f2EfjyNRjm0blM@J@0e4lsaA0S/nErJ71g1yhOFthFaRcMbdr3ARqFtnnZgjgyd6bEmfhPBIL@yXA56oJjAu7KFbqXy3ShO@3Wdh2RMBoMpg@VCtv/mV5dlJRTrqCxn@BWm9sh9I/oFTrQpuEInQi8DUdyDMX2owtOTukbmobgOu5x6K25z7vDkwXN9cOj59bUq9jvoJcbYu@oKWzSF3bQbNtGmXCwq28835EpqQN1t8WqPZgFOzTM8lhF/3Ey6IL5XeDXpj0NpOKizjn2dsHjCZQ8PoJ6VV6Gd@AxqGbb2HXh/F1u2TxhRaEm9x4ozS@WkA8qhO7Y5m0ibWGLYhaugpfjophz79OIz826@uJ2cP@8uEPIoSQHYjyRWoaLoJJ10fL5aCzFLE6OQ@eLMkXfdMGoWBEzBauCBJq/GUR3P7AcoRS5QDl/E@KngwFM@yDIQ8b3R6O@/DgcT@KP46Pe4fifZiXoCT1cB6tL6bwQyEa76qDNTenhOsgvteW9DxUdtrN7MSVU2Yu/YZtYRV6FAt0pIqIvv0sti4glXL7uye5YNKTs/Yw347Y/C8S786wN9WwJUKLs3J3RhbVq869Q0J702mJ2FcokCie4yP3NUYGhV3Qe9oxQ1@WB/PmTOwsn9p9ICTsf7mF7kknF6n0SXj/PhMn9o3M2RHLX@zTsPwGLRirDzr3W5f0nyZ04WJwbHcsm7j8Z3t/v@fvPIZTRvfNjIbyZ4/N0Zs1SFEdfb2OW7X3BFy3fDej5jPmFw4H/wBKg6BLAfnhwhL98oZKGPw/BMIPwvFgXCJYA7tZwD6U@teUs9E7nouZVUemk99VXA2/esvinEJ/0BIp2PxHogE2NDDpHA9CL8eMXFg@J5/DCXJUXdl5zE3PZ6JPsxNz@tyoPIr/aD7vxdq18WSX7XwdNEPxff1oFWb17gMIVrncumHKftCo5ruRvPvF2/DwNFKadl8eWJMA9fvpsQYm21tgz0AuU5YdDL1qh1aDVLb5p89A/uUZVaXbkcEguC@evZ8k@Wsz9lPabxnJ/W7j3d9tKxnzRTO6CO60ko2MDud9rrLy1VNAhGIp/i51i4sK7IQc5pT7/Hw "Kotlin – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~134~~ 123 bytes
```
f=lambda n:sum(map(int,n.translate(n.maketrans('ADGJMPTWBEHKNQUXCFILORVYSZ','23456789'*3+'79','()+-./ '))))+10*n.count('0')
```
[Try it online!](https://tio.run/##VY1NT8JAFEX3/IrZvVfKlDcdpx8mLFSKKAUqiEB3o0I00qGBYeGvL4UFSe/unnOTW/7bn72RVbXt7XTx@a2ZuT@eCix0ib/GdoxnD9ocd9pu0HiF/ttcO8JD//l1nL0vH5PhaPK2WD0NXtLp7GM9z6EDvrxTQRjF0JYuhHFN0HG512Xg1HEFtY33tT8Zi0DgVOWhvsItQixEvWjdehSEXEmKGzAUkimlGAlfNoQrGPrCd1iWBFwRUcMKHhHxQTpdJrN5w2SLPE@TC6vO "Python 3 – Try It Online")
-11 bytes thanks to @dan04
]