[Question]
  [
Write a program or function which takes a string of text as input and outputs the number of non-alphabetical characters in it (standard I/O rules apply). A non-alphabetical character is any character not appearing in this string:
```
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
```
In terms of ASCII character codes, that's anything not in ranges 65-90 inclusive or 97-122 inclusive.
## Rules
Your program must be able to handle all of printable ASCII, as well as any characters that appear in your code. In other words, you may assume input will not contain any characters iff they are in neither printable ASCII nor your solution. Printable ASCII here means ASCII's character codes 32-126 inclusive as well as character code 10 (Meaning you *will* have to count spaces and newlines).
You may assume that input will not be empty.
## Scoring
Your score is the number of non-alphabetical characters (not bytes!) in your code. Lowest score wins, with [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") as a tie-breaker.
## Examples
```
"input" => output
"example" => 0
"3xampl3" => 2
"Hello, World!" => 3
"abc.def-" => 2
"     " => 5
"IT'S NORMAL" => 2
"•¥¥€???!!!" => 10
"abc
def" => 1
```
  
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), score 0, 4 bytes
```
kLFL
```
Yes, you heard me right. Flagless, score 0, 4 bytes.
## Explanation
```
kLFL
kL    Uppercase and Lowercase alphabet
  F   Filter out the input
   L  Take the length of that
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrTEZMIiwiIiwiSGVsbG8sIFdvcmxkISJd) |
[3 bytes with flag](https://vyxal.pythonanywhere.com/#WyJsIiwiIiwia0xGIiwiIiwiSGVsbG8sIFdvcmxkISJd)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal) -v, 36 bytes, score 0
```
CastLengthFilterqNotCountaUppercasei
```
[Try it online!](https://tio.run/##S85ILErOT8z5/985sbjEJzUvvSTDLTOnJLWo0C@/xDm/NK8kMbSgILUoObE4NfP//2glJaXEpGSulNQ0ICv2v24ZAA "Charcoal – Try It Online") Explanation: Charcoal's verbose parser is somewhat lax, not always requiring things like parentheses, spaces, commas, or correct capitalisation. The verbose program would be more conventionally written something like this:
```
Print(Cast(Length(Filter(q, Not(Count(a, Uppercase(i)))))));
```
`q` is the first input, `a` is the predefined variable for the uppercase alphabet and `i` is the default outer loop variable.
[Answer]
# [Husk](https://github.com/barbuz/Husk), Score 0, ~~13~~ 11 bytes\*
```
mLfopVDkDma
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8X@uT1p@QZhLtktu4v///6OVUisScwtyUpV0lIzBLGMgyyM1JydfRyE8vygnRRHIT0xK1ktJTdMFMhVAAEh7hqgHK/j5B/k6@gB5jxoWHVp6aOmjpjX29vaKilA9MXlATUqxAA "Husk – Try It Online")
The basic idea is to filter for non-alphabetic characters and calculate the length. [Husk](https://github.com/barbuz/Husk) has a builtin (`D`) to identify uppercase characters, and we can convert the lowercase characters to uppercase first using `a`.
But now we need to filter to keep only falsy elements. This isn't very straightforward in [Husk](https://github.com/barbuz/Husk): the builtin 'NOT' command is the (non-alphabetic) `¬` character, so we need to engineer an alternative to this.
This is accomplished here by first grouping elements into lists, and getting the index of the first truthy element of each list (so, lists of truthy elements return `1` and lists of falsy elements return `0` for 'not found'). After this, getting prime factors (`p` command) was the trick: this returns a non-empty list (=truthy) containg a single `0` element for `0`, and an empty list (=falsy) for `1`.  
And a few other little tricks to get the length of the resulting single-element list.
Altogether:
```
FYmLfopVDkDma
           m   # Map across each character in the input:
            a  #   convert to uppercase;
         k     # now, group the characters by:
          D    #   are they an uppercase letter?
               #   (zero for non-uppercase letters, ASCII value for uppercase letters);
    f          # now filter this list by:
     o         #   the combination of these two commands:
       VD      #      first index of an uppercase letter (or zero if not found)
      p        #      prime factors of this (so non-empty list for groups of non-letters, empty otherwise)
               # Now we've got a single-element containing all the 
               # non-alphabetic characters of the input, or an empty list if there aren't any.  
               # We need to get the length of this single element (or zero if there isn't one).  
  m            # So: map across this list (it only has one element)
   L           #   getting the element length(s)
               # Output formatting:
F              # Fold across this (single-element) list of lengths,
 Y             #   getting the maximum value (so the value of the only element)
```
---
\*outputs an empty list for zero non-alphabetic characters, and a single-element list containing the number of non-alphabetic characters otherwise. Add 2 bytes (`FY`) to output the number of non-alphabetic characters in a non-listed fashion [Try it online!](https://tio.run/##yygtzv6f@6ip8b9bZK5PWn5BmEu2S27i////o5VSKxJzC3JSlXSUjMEsYyDLIzUnJ19HITy/KCdFEchPTErWS0lN0wUyFUAASHuGqAcr@PkH@Tr6AHmPGhYdWnpo6aOmNfb29oqKUD0xeUBNSrEA "Husk – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), score: 0 (7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage))
```
ADuJSKg
```
[Try it online](https://tio.run/##yy9OTMpM/f/f0aXUK9g7/f9/j9ScnHwdhfD8opwURQA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeV/R5fSQ6uDvdP/6/yPVsrMKygtUdJRSq1IzC3ISQWyjMEsYyDLIzUnJ19HITy/KCdFEchPTErWS0lN0wUyFUAASHuGqAcr@PkH@Tr6AHmPGhYdWnpo6aOmNfb29oqKUD0xeUBNQCbQXi@gtUDW4YUX9qQrxQIA). (The `J`oin in the test suite has been replaced with a concat `«`, because it would otherwise join the input that's already on the stack with it.)
The straight-forward shortest approach would be 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) with a score of 2:
```
áмg
```
[Try it online](https://tio.run/##yy9OTMpM/f//8MILe9L///dIzcnJ11EIzy/KSVEEAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/8MLL@xJ/6/zP1opM6@gtERJRym1IjG3ICcVyDIGs4yBLI/UnJx8HYXw/KKcFEUgPzEpWS8lNU0XyFQAASDtGaIerODnH@Tr6APkPWpYdGjpoaWPmtbY29srKkL1xOQBNQGZji6lXsHe6UAW2HqlWAA).
**Explanation:**
```
A       # Push the lowercase alphabet
 D      # Duplicate it
  u     # Uppercase the copy
   J    # Join the two alphabet on the stack together
    S   # Convert it to a list of characters
     K  # Remove all those characters from the (implicit) input-string
      g # Pop and push the length to get the amount of remaining non-letters
        # (which is output implicitly as result)
á       # Only leave all letters of the (implicit) input-string
 м      # Remove all those letters from the (implicit) input-string
  g     # Pop and push the length to get the amount of remaining non-letters
        # (which is output implicitly as result)
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), score 0, 8 bytes
```
oMSaRMXA
```
[Try It Online!](https://dso.surge.sh/#@WyJwaXAiLG51bGwsIm9NU2FSTVhBIiwiIiwiXCJBQjlcbkBBXCIiLCIiXQ==)
-3 thanks to DLosc.
```
    RM   # Remove...
      XA # Letters
   a     # From input
 MS      # Sum result when mapping each to...
o        # 1
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), Score 0, ~~14~~ 11 bytes
```
lfqZhxGrTZQ
```
[Try it online!](https://tio.run/##K6gsyfj/PyetMCqjwr0oJCrw/38lj9ScnHwdhfD8opwURSUA "Pyth – Try It Online")
`G` is the lowercase alphabet in Pyth. There's no built-in for the uppercase alphabet, so we convert each letter of the input to lowercase.
**Explanation**
`f ... Q` Filter for elements of the input where...
`xGrTZ` ...the index of the lowercased letter in the lowercase alphabet ...
`h` ...plus one...
`qZ` ... equals 0
(This works because `x` returns -1 for elements not in the string, like in Python)
`l` Length of the resulting list
[Answer]
# [R](https://www.r-project.org/), score 9, 38 bytes
```
function(x)sum(!tolower(x)%in%letters)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQrO4NFdDsSQ/J788tQjIVc3MU81JLSlJLSrW/J@mkZqjUVxSVFyQk1mioZRakZhbkJOqpKOkpKmpqaxga6dgwIWmxhisxhhZjRG6Go/UnJx8HYXw/KKcFEVklcboKhOTkvVSUtN08RqnAALIKkzRVXiGqAcr@PkH@Tr64DXpUcOiQ0sPLX3UtMbe3l5REcVthgZYHMcFdByKIjQ16sQFtDrEiP8A "R – Try It Online")
Takes input as a vector of characters.
---
# [R](https://www.r-project.org/), score 14, 85 bytes
```
function(x)nchar(gsub("[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]","",x))
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQjMvOSOxSCO9uDRJQyk6MSk5JTUtPSMzKzsnNy@/oLCouKS0rLyissrRydnF1c3dw9PL28fXzz8gMCg4JDQsPCIyKlZJR0lJp0JT83@ahlJqRWJuQU6qkqaygq2dggEXUMgYLGQMFTICCXmk5uTk6yiE5xflpChCJYxBEkD79YAO0EVWrAACUAFTkIBniHqwgp9/kK@jD7K6Rw2LDi09tPRR0xp7e3tFRZi5hgZQg7mABsPEgELqNAkDdc3/AA "R – Try It Online")
Takes input as a proper string.
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), Score 0, 9 bytes
```
qrdfnsait
```
[Try it online!](https://tio.run/##SyotykktLixN/V@trmRtbaio@L@wKCUtrzgxs@R/bXjOf6XUisTcgpxUJQVbOwUDLiVjMNcYzDXiUvJIzcnJ11EIzy/KSVEECxpzKSUmJeulpKbpwhQpgACYY8ql5BmiHqzg5x/k6@gDk3/UsOjQ0kNLHzWtsbe3V1SEmGNoADZIAWgQhA8A "Burlesque – Try It Online")
```
qrd  # Quoted isalpha
fn   # Filter not
sa   # Non-destructive length (ordinary length is L[)
it   # Drop everything but the top of stack
```
Absolute shortest doing the same thing would be:
```
`FrdL[
`F   # Filter not
rd   # isalpha
L[   # Length
```
For fun, the inverse challenge:
```
^^ ^^ ^^ ^^ ^^           # Create 5 copies
).%++\/                  # Count isPunctuation; add; swap
).*++.+\/                # Count isSymbol; add; swap
)<>++.+\/                # Count isDigit; add; swap
" "~?)-])**++32./.+\/    # Count spaces; add; swap (is whitespace is "ra")
"   "~?)-])**++9./.+\/   # Count tabs; add; swap
"
"~?)-])**++10./.+        # Count newlines; add; swap
```
[Try it online!](https://tio.run/##SyotykktLixN/V@trmRtbaio@D8ODrg09VS1tWP0gbSWtrYemGVjB2UpKSjV2WvqxmpqAeWMjfT0IaKcSKKWMEEuJEFDA5Do/9rwnP9KqRWJuQU5qUoKtnYKBlxKxmCuMZhrxKXkkZqTk6@jEJ5flJOiCBY05lJKTErWS0lN04UpUgABMMeUS8kzRD1Ywc8/yNfRByb/qGHRoaWHlj5qWmNvb6@oCDHH0ABskALQIAgfAA "Burlesque – Try It Online")
[Answer]
# Java, score: 14 (46 bytes)
```
s->s.filter(c->!Character.isLetter(c)).count()
```
Input as a Character-stream.
Doesn't work if the input contains non-ASCII letters (e.g. `é`), but that's allowed according to the challenge rules.
[Try it online.](https://tio.run/##lVDBTgIxFLzzFW/3YhvYXrhBhBgukgAmYuJBPTy6XSx22822ixpCYvwUE25@BZ/Cj6yPFbx7aWde5k1nusI1Jqv0pZYGvYcpartpAWgbVJmhVDA7UgDj7BIkW5FcVEEb4UOpMBdjG@YNAs/7pNy26PABg5YwAwuXtU8GXmTakCGTySAaPWOJkpjQfqJCM@ZcSFfZwHjdPxoU1cKQwcln7XQKOSVj9JS2y4cn5L@pMleyNZYQlA8j9Ap6YNUrnGWbWNuiCnEnVm@YF0YR6jaoS@haGeM6cO9Kk0bEcSFFqrKE4NEb6B7fXcxhdnM7vZoQO3x87Xf73eHzezgcRtFp59HSEsH/9Yy3vGkAMH/3QeXCVUEUFDsYy8512nEP4rYV8m8iJLl6xvnps7f1Dw)
**Explanation:**
```
s->                          // Method with IntStream parameter & long return
  s.filter(c->               //  Filter the character of the input-stream by:
     !Character.isLetter(c)) //   It's NOT a letter
   .count()                  //  Count how many are left
```
[Answer]
# [Haskell](https://www.haskell.org/), score 6, 81 bytes
```
length.filter(flip notElem"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P802JzUvvSRDLy0zpyS1SCMtJ7NAIS@/xDUnNVcpMSk5JTUtPSMzKzsnNy@/oLCouKS0rLyissrRydnF1c3dw9PL28fXzz8gMCg4JDQsPCIySknzf25iZp5tSj6XgkJBUWZeiYKKQpqCEm5rYsiyJ0ZJU@k/AA "Haskell – Try It Online")
The non-alphabetic characters are `.( "")`.
Also score 6, but 4 bytes longer is:
```
fmap length$filter$flip notElem"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
```
[Try it online!](https://tio.run/##nc1HDsIwEADAO69YWf5GDpTQQu@gXAzxxibrQmLq580TkJgPjBJNJYlixASN8EDSlkFx1BRkzZG0B@tCStIwcb4UEkulrxUZ6/ytbsL98Xy9P@1Ot5f2B8PROJtMZ/PFcrXebHf7w/HEohHaJoVrAfha2wAcENiPKv/ryhmLXw "Haskell – Try It Online")
[Answer]
# [Factor](https://factorcode.org/), score 5 (82 bytes)
```
readln "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"without length pprint
```
[Try it online!](https://tio.run/##Hc05FoIwEADQq8zjCnRauSIuuCBuXYABoiEJySDg5aPP7ne/YBkp45I4jIIRcAXaINGgDZcEFpsWZYb2J7IwdgZZLiR4LM1yLMqKP1@ilko3xlL77vrhM5nO5otlsArXm@0u2h@Op/icXK63@8PrOFWqJRAoS6pA/w/n/J7VWvhf "Factor – Try It Online")
For once I can get a better score by reading from standard input!
[Answer]
# JavaScript (in Browser), Score 4, 120 bytes
```
eval(atob`ZXZhbCgicyAgPSIrICAiPnMubWEiKyAidGNoKCIrICIvWyIrICAiXmEtekEtWiIrICJdLyIrImcpPyIrICIubCIrImVuZyIrInRoIHwgMCIp`)
```
```
f =  eval(atob`ZXZhbCgicyAgPSIrICAiPnMubWEiKyAidGNoKCIrICIvWyIrICAiXmEtekEtWiIrICJdLyIrImcpPyIrICIubCIrImVuZyIrInRoIHwgMCIp`)
console.log(f("example"      )) // 0
console.log(f("3xampl3"      )) // 2
console.log(f("Hello, World!")) // 3
console.log(f("abc.def-"     )) // 2
console.log(f("     "        )) // 5
console.log(f("IT'S NORMAL"  )) // 2
console.log(f("•¥¥€???!!!"   )) // 10
console.log(f("abc\ndef"     )) // 1
console.log(f("eval(atob`ZXZhbCgicyAgPSIrICAiPnMubWEiKyAidGNoKCIrICIvWyIrICAiXmEtekEtWiIrICJdLyIrImcpPyIrICIubCIrImVuZyIrInRoIHwgMCIp`)"))
```
In readable form:
```
s=>s.match(/[^a-zA-Z]/g)?.length|0
```
[Answer]
# CJam, score 0, ~~95~~ ~~89~~ 82 bytes
```
qeuWcibWcibKAbFbAbHbAbIbfbXfbKBbKbAbDbAbKbfbKYbKbYbCbfbXdfmdUfmOGYbCbfbUfbXfbUfbXb
```
[Try it.](http://cjam.aditsu.net/#code=qeuWcibWcibKAbFbAbHbAbIbfbXfbKBbKbAbDbAbKbfbKYbKbYbCbfbXdfmdUfmOGYbCbfbUfbXfbUfbXb&input=%20!%22%23%24%25%26%27()*%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D%7E)
### Explanations
```
qeu                       e# Read input and convert to upper case.
65535b65535b              e# Convert to base 65535 and back, to cast characters to integers.
91fb                      e# Convert each element to base 91.
1fb                       e# Sum the digits in each element.
                          e# Only letters would end up greater than or equal to 65.
65fb                      e# Convert each element to base 65.
2220010939706446080fb     e# Convert each element from base 2.22e18.
1dfmd                     e# Divmod each element by floating point 1 to cast to floating point.
                          e# All letters would become the same number due to floating point inaccuracy.
                          e# It will also generate some extra 0s as the remainder but doesn't matter.
0fmO                      e# Cast elements back to integers.
20736fb0fb                e# Convert each element to base 20736 and get the last digit.
                          e# 20736 is a divisor of the number about 2.2e18, 
                          e# so the last digit generated from a letter would be 0.
1fb0fb                    e# Convert each element to unary and get the last digit.
1b                        e# Sum the elements.
```
With the constants:
```
0        U
1        X
65       KBbKbAbDbAbKb    Convert 20 to base 11 (=19), from base 20 (=29), to base 10,
                            from base 13 (=35), to base 10, from base 20.
91       KAbFbAbHbAbIb    Convert 20 to base 10, from base 15 (=30), to base 10,
                            from base 17 (=51), to base 10, from base 18.
*170     AZbDb            Convert 10 to base 3 (=101), from base 13.
*196     GZbDb            Convert 16 to base 3 (=121), from base 13.
20736    GYbCb            Convert 16 to base 2, from base 12.
65535    Wci              Cast -1 to character, then back to integer.
2.22e18  KYbKbYbCb        Convert 20 to base 2, from base 20, to base 2, from base 12.
*Only used in an old version.
```
It depends on floating point inaccuracy. The number 2.22e18 won't change if a small number less than 26 is added to it.
CJam has a bug using divmod on a too big high precision integer and a float.
[Answer]
# [Zsh](https://www.zsh.org/), score 6, 64 bytes
```
tr -d abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ|wc -c
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjwYKlpSVpuhY3HUqKFHRTFBKTklNS09IzMrOyc3Lz8gsKi4pLSsvKKyqrHJ2cXVzd3D08vbx9fP38AwKDgkNCw8IjIqNqypMVdJMh5kCNW0At8wA)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 110 bytes
```
+>>,[<++++[----->>->+>+<<<<]----[---->-<]>->+>[--<<-[<]<[>>>+<<]>>>]<<------>>>[--<<<-[<]<[>>>+<<]>>>>]<<<,]>.
```
[Try it online!](https://tio.run/##ZYxRCoAwDEMPtM0ThKDXsBScgiCCH4I/evi6bv6Zn5LkNfOZt2O9lt1ClSSS4RMAtUBGQetcZGKgd1D3NWWC1rw4IAkU4kOFKUdL9P024Ec4gqjszPphlCnfzws "brainfuck – Try It Online")
Accepts input as ASCII. outputs as binary. The header adds 48 (ASCII 0) to the count so that small outputs appear as ASCII digits.
This is a complete rewrite of my previous answer below, taking into account everything I could have done better. In particular, I set up a specific cell with a 1 in it to help with the IF operation instead of trying to use other nonzero cells to assist.
There are a few more bytes to save with this approach if I have time later. It's still the highest scoring answer, but it isn't the longest anymore, which is gnerally as good as it gets with Brainfuck.
```
+>>                     Put a 1 in cell 0 then move to cell 2
,[                      take an input in cell 2 and loop until end of string marked by 0 encountered
<++++[----->>->+>+<<<<] Put 260 mod 256=4 in cell 1; iterate 260/5=52 times to subtract 52 from cell 3 and store 52 in cells 4 and 5
----[---->-<]>-         Put minus 4 = 252 in cell 1; iterate 252/4=63 times to subtract 63 from the input; then reduce by one more  
>+>                     add 1 to cell 3
[--<<-[<]<[>>>+<<]>>>]  iterate 26 times UPPERCASE using 52 in cell 4; if not zero add 1 to cell 3 
<<------>>>             subtract 6 from the input 
[--<<<-[<]<[>>>+<<]>>>>]iterate 26 times LOWERCASE using 52 in cell 5; if not zero add 1 to cell 3
<<<                     overall cell 3 has increased by 0 if input is a letter or 1 if not a letter
,]                      take more input into cell 2 until end of string marked by 0 encountered
>.                      output count from cell 3 
```
# [brainfuck](https://github.com/TryItOnline/brainfuck),  ~~146~~  138 bytes
```
,[<++++[-----<-<+<+<+>>>>]>----------<<<<<[->>>>>-<<<<<]>>>>>--<<<<[-->>>>-[<]<[+>]<<<]>>->>------<<<[-->>>-[<]<[+>]<<]>++[->>>+<<<]>>,]>.
```
I misread the question and assumed all characters except `AZaz`and newline should be counted. I now realise newlines need to be counted like any other non `AZaz` character which makes the code slightly shorter. If I had not considered newlines at all, the code might be shorter still, but the setup loop 260/5=52=2\*26 is pretty efficient.
[Try it online!](https://tio.run/##TY47CoBADER7T2GfjScIg17DEPADgggWgo0eft01svjSZDIzkOkY13055y3SizJAHyKGGFT8nhEWyoOEgQuSydWEC/Od3XgdVjFRgrnNQCl74hcw@CsgDwdDE2NVt12vw3jdDw "brainfuck – Try It Online")
Accepts input as ASCII. outputs as binary. The header adds 48 (ASCII 0) to the count so that small outputs appear as ASCII digits.
**Commented code**
```
,[                        Take an input; If nonzero start looping
<++++                     Move left and add 4 to make (256+4)=260 mod 5 
[-----<-<+<+<+>>>>]>      Loop 52 times to setup 3 cells with 52 and one with minus 52 
----------<               Subtract 10 from input
<<<<[->>>>>-<<<<<]>>>>>-- Subtract another 52+2=54 from the input 
<<<<[-->>>>-              Loop 52/2=26 times reducing the input by 1 each time for UPPERCASE
  [<]<[+>]                If the input is nonzero increment the cell that contained minus 52
<<<]                      Ultimately the cell with minus 52 will be incremented 51 times for AZaz 52 for other
>>->>------               Subtract 1 from cell that contained minus 52 to avoid it reaching 0; and 6 from input
<<<[-->>>-                Loop 52/2=26 times reducing the input by 1 each time for LOWERCASE
  [<]<[+>]                If the input is nonzero increment the cell that contained minus 52
<<]
>++                       Cell that contained minus 52 now has minus 2 for AZaz or minus 1 for other; increment by 2
[->>>+<<<]                Copy the value 0 or 1 into the final total
>>,]                      Take the next input and if nonzero continue to loop
>.                        Output the final total
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jellylanguage), score 3, 4 bytes
[@caird-coinheringaahing](https://codegolf.stackexchange.com/users/66833/caird-coinheringaahing) saves 1 byte!
```
ḟØẠL
```
[Attempt This Online!](https://tio.run/##y0rNyan8///hjvmHZzzctcDn////Sh5AsXwdhfD8opwURSUA)
**Explanation:**
Filter alphabetic characters from input, then return length
[Answer]
# [Perl 5](https://www.perl.org/) `-F/[^a-z]/si -0`, score ~~5~~ 2 (6 bytes)
*@DomHastings saves 3 points*
```
say$#F
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJF2e3/f88Q9WAFLj//IF9Hn3/5BSWZ@XnF/3V9TfUMDA3@67rpR8cl6lbF6hdn/tc1AAA "Perl 5 – Try It Online")
Abusing the command line flags for all they're worth. The `-F` flag with its regex breaks the input apart on anything that isn't a letter and stores those fields in @F. Therefore, there is one element added to @F for each nonalphabetic character. `-0` grabs all of the input at once (slurp mode). The actual code code outputs the last index of @F since there will always be at least one member of @F (assuming input is not null).
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), score 5, 39 bytes
```
sStringLength@s-Total@LetterCounts@s
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zg@7/4/aSFwSVFmXnpPql56SUZDsW6IfkliTkOPqklJalFzvmleSXFDsX/A4BKSqKVFXTtFNIclGMV1BT0HRSqlVIrEnMLclKVdBSUjMFMYxDTIzUnJ19HITy/KCdFESSQmJSsl5KapgtiK4AAiOEZoh6s4Ocf5OvoA@I@alh0aOmhpY@a1tjb2ysqwvTF5AE1gthEulSp9j8A "Wolfram Language (Mathematica) – Try It Online")
Doesn't work if the input contains non-ASCII letters (e.g. `այբուբեն`).
The private-use character `` is `\[Function]`.
[Answer]
# [Perl 5](https://www.perl.org/) + `-n0 -M5.10.0`, Score: 3, 14 bytes
```
say s M\PlMMig
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoic2F5IHMgTVxcUGxNTWlnIiwiYXJncyI6Ii1uMFxuLU01LjEwLjAiLCJpbnB1dCI6InNheSBzIE1cXFBsTU1pZyJ9)
[Answer]
# [Alumin](https://github.com/ConorOBrien-Foxx/Alumin), Score 0 (82 bytes)
```
iqipkmddhhdtddtthaueyddhhhdtdhatveyddhhhhhhhdthhthcueydhhhdhathcdthavetrtahycmzfaf
```
[Try it online!](https://tio.run/##LcrLCYAwEIThVrxZh0fBB6gNLFnDBI2obAKx@ZgVj98/Q3vw7sjZXe7cPDPAwiwCCmtSqkESf@ErgMDoQVVWmNIornILIRn/WLI5t0s9V8M49U33Ag "Alumin – Try It Online") I thought this would be a funny submission, since it is almost impossible to get a score of anything more than 0 without introducing no-ops, since the only defined operations are the lowercase English alphabet. (Technically, you would use a space to separate two integer sequences in a row, but you can golf around that if necessary, and it didn't come up here.)
## Commented code
```
i                       PUSH INPUT CHARACTER
q                       WHILE TOP OF STACK > 0 {
  i                         PUSH INPUT CHARACTER
p                       }
k                       DISCARD EOF
m                       MAP EACH STACK ELEMENT OVER {
                            OUR STACK CONSISTS OF JUST A CHARACTER
  dd                        DUPLICATE INPUT TWICE
  hhdtddttha                PUSH (2*2)*(2*2)*(2*2)+1
                            (AKA 65)
  ue                        PUSH MAX(INPUT, 65) == INPUT
                            (AKA INPUT >= 65)
  ydd                       DUPLICATE INPUT TWICE
  hhhdtdhat                 PUSH (3*3)*((3*3)+1)
                            (AKA 90)
  ve                        PUSH MIN(INPUT, 90) == INPUT
                            (AKA INPUT <= 90)
  ydd                       DUPLICATE INPUT TWICE
  hhhhhhhdthhthc            PUSH (7*7)*2-1
                            (AKA 97)
  ue                        PUSH MAX(INPUT, 97) == INPUT
                            (AKA INPUT >= 97)
  yd                        DUPLICATE INPUT ONCE MORE
  hhhdhathcdtha             PUSH ((3*(3+1))-1)*((3*(3+1))-1)+1
                            (AKA 122)
  ve                        PUSH MIN(INPUT, 122) == INPUT
                            (AKA INPUT <= 122)
                            STACK NOW LOOKS LIKE:
                            [B1 B2 B3 B4]
  t                         PUSH AND(B3, B4)
  r                         REVERSE STACK
                            [AND(B3,B4) B2 B1]
  t                         PUSH AND(B2, B1)
  a                         PUSH OR(AND(B3,B4), AND(B2, B1))
  hyc                       PUSH NOT(^)
                            (AKA 0 FOR ALPHABETIC, 1 ELSE)
m                       }
zf                      FOLD ENTIRE STACK USING SEED 0 {
  a                         ADD TOP TWO
f                       }
```
Not 100% sure the constants are optimal, but for now I'm satisfied.
[Answer]
# [Rust](https://www.rust-lang.org), score 14, 42 bytes
```
|s|s.replace(char::is_alphabetic,"").len()
```
[Attempt This Online!](https://ato.pxeger.com/run?1=dZDPTsJAEMbjlaeYNgR3SWlUYmKKYLxp4p9ETLyYNMuyazcupXaXoEKfxAsHfSh8BJ_CYdsghLiX2cxv5ptv5uMznxi7WP7IFEZMpYTCrAb4Rozn4zifaGE8mCqbxMbmKn2q8OqROqnbyFrapNDtbYA1pM0AyjYl37wqRUOTaWXjaaKsMBnjgtCQj7UW3EbRad_V9wila72i475FzQUtLBAZgDQ0wk9KGjiCQqsHE6PeRQClAnpaC2z498jXxMrWybI5N3MT5iLTKwc8YXkUKRMznSVsIKzige_TUAs8Sdnxvfew0qKdPxs8EfwZujA3EaxcBJDON-7AjBG5jcWLRyQxFCntrGGGbqxOPeLPorPCHbDw8Vy4GNZWhUU1zA0ivnhlo0wLLDuoCirQdqCN4GgbXAitxwFMx7keeojb25gNeDgUsrXb6Dxi-ng7fXm_34eb27vr86vdHlR7TFEOyWFF_tlSujUb0i1alPddLMr4Cw)
Only works for ASCII inputs, because `str::len` is counting bytes instead of characters.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 55 bytes, score 3
```
[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPzouMSk5JTUtPSMzKzsnNy@/oLCouKS0rLyissrRydnF1c3dw9PL28fXzz8gMCg4JDQsPCIyKvb//9SKxNyCnFQuYzBtzOWRmpOTr6MQnl@Uk6LIBTRUD2iqLpcCCHB5hqgHK/j5B/k6@nA9alh0aOmhpY@a1tjb2ysqKgIA "Retina 0.8.2 – Try It Online") Link includes test suite, so final example with newline isn't included. [Try it online!](https://tio.run/##K0otycxL/P8/Oi4xKTklNS09IzMrOyc3L7@gsKi4pLSsvKKyytHJ2cXVzd3D08vbx9fPPyAwKDgkNCw8IjIq9v9/oDYuoD4A "Retina 0.8.2 – Try It Online") Final example only.
[Answer]
# [Python 3](https://docs.python.org/3/), score 11, 39 bytes
```
lambda s:sum(not x.isalpha()for x in s)
```
[Try it online!](https://tio.run/##Pc4xasNAEAXQ2nOKUZVdsN2oMwSRwiGB2ALHkMbN2hqhhdXuMrMicmdylIC6nMJH8UVkO5D85vPhFy8eUxN8PtaPu9GZdl8ZlIV0rfIhYT@3YlxsjNJ1YOzRehQ9Jj4uYPLZWEe45Y5uYxLZ@qRqZX3sktJaA/UHigmX5fOSOfDtFI3ISL1poyPIfzuHF3IuTPEjsKsyMPvDvKJ6BngPvG4f3nFdblZPb3A5fZ@H83D5@imKIssy@Oc68kr07K5uTVSS@M89Fa2v "Python 3 – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 11 Score, 32 bytes
```
s=>s.Count(c=>!char.IsLetter(c))
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU1xSlJmXrpOZV2KXZvu/2NauWM85vzSvRCPZ1k4xOSOxSM@z2Ce1pCS1SCNZU/O/NVcAUH2JRpqGkmeIerCCn3@Qr6OPkqYmkgQhQ0Cq/wMA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), score 4, 40 bytes
```
ss~StringCount~Except@LetterCharacter
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7v/j9pIXFdcElRZl56c75pXklda4VyakFJQ4@qSUlqUXOGYlFiclAxv8AoIqSaGVduzQH5Vi1uuDkxLy6ai6l1IrE3IKcVCUdLiVjMNMYxPRIzcnJ11EIzy/KSVEECSQmJeulpKbpgdgKIABieIaoByv4@Qf5OvqAuI8aFh1aemjpo6Y19vb2ioowfVxAfUpctf8B "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), score 9, 40 bytes
```
lambda s:map(str.isalpha,s).count(False)
```
[Try it online!](https://tio.run/##jY7BCoJAFEXXzldMq0YwF7kTWrRQCiqhhDZBPPWJwjgzvBlRv36yvqC7ORw4i2sW12m19@3h5SUMVQPcpgMYYR3FvQVpOohsGNd6VE7kIC2G3tGSsmDqeom8pBFXCQz1yvFWEEzvXpnRiTBkONdoHM@KPCPStHYGrPU4w2AksuTHhJ1QSh3xpybZbBhUddxgu2P8O3Yutw9@K@7X44X9@/AD "Python 2 – Try It Online")
[Answer]
# [APL (APLX)](https://apl.wiki/APLX) Score 6, 8 bytes
```
⍴⍞∼⎕A,⎕a
```
`⍴` shape of…
`⍞` input…
`~` without…
`⎕A` upper case **A**lphabet…
`,` and
`⎕a` lowercase **a**lphabet
[Answer]
# [C (gcc)](https://gcc.gnu.org/), Score 16 (48 bytes)
```
main(c){return~c?!isalpha(c)+main(getchar()):c;}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1mzuii1pLQory7ZXjGzODGnICMRKKgNlkxPLUnOSCzS0NS0SrauJV0HAA "C (gcc) – Try It Online")
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 59 bytes, score: 8 ~~10~~
```
$input-replace"[abcdefghijklmnopqrstuvwxyz]"|foreach Length
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/f9fJTOvoLREtyi1ICcxOVUpOjEpOSU1LT0jMys7Jzcvv6CwqLiktKy8orIqVqkmDaglMTlDwSc1L70kgzLNAA "PowerShell Core – Try It Online")
*-2 bytes thanks to [user314159](https://codegolf.stackexchange.com/users/78395/user314159)*
[Answer]
# JavaScript (ES6), Score 12 (64 bytes)
*-1 point thanks to @l4m2*
```
s=>s.replace(/[abcdefghijklmnopqrstuvwxyz]/gi,new String).length
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1q5Yryi1ICcxOVVDPzoxKTklNS09IzMrOyc3L7@gsKi4pLSsvKKyKlY/PVMnL7VcIbikKDMvXVMvJzUvvSTjf3J@XnF@TqpeTn66RpqGUmpFYm5BTqqSAhhoairo6ysYcKEpMgYrMkZRZISuyCM1JydfRyE8vygnRVEJosgYXRHQvXpAB@sq4TMJLAe1DKbIFF2RZ4h6sIKff5Cvo48STpMeNSw6tPTQ0kdNa@zt7RUVFZXg5hkaYHFaTB7QbchOM@RCU5WmV5IPCVANTU3N/wA "JavaScript (Node.js) – Try It Online")
]