[Question]
  [
The alphanumeric characters have ASCII-values:
```
0-9  ->  48-57
A-Z  ->  65-90
a-z  ->  97-122
```
Your challenge is to take an integer as input, and output how many characters can be made using consecutive digits of that number. The character codes may be overlapping. `666` should result in `2`, since you have `66` twice.
**Test cases:**
```
Input: 5698
Possible characters: '8' (56), 'E' (69), 'b' (98)
Output: 3
Input: 564693
Possible characters: '8' (56), 'E' (69)
Output: 2
Input: 530923864209124521
Possible characters: '5' (53), 'V' (86), '4' (52)  
Output: 3
Input: 1111111
Possible characters: 'ooooo' (5*111)
Output: 5
Input: 5115643141276343
Possible characters: '3' (51), '8' (56), 'L' (76), 's' (115)
Output: 4
Input: 56789
Possible characters: '8' (56), 'C' (67), 'N' (78), 'Y' (89)
Output: 4
Input: 94
Possible characters: ''
Output: 0
Input: 1
Output: 0
```
Input and output formats are optional (yes, you may take the integer as a string).
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~8~~ 7 bytes
```
žKÇIŒÃg
```
[Try it online!](https://tio.run/nexus/05ab1e#@390n/fhds@jkw43p///b2poaGpmYmxoYmhkbmZsYgwA "05AB1E – TIO Nexus")
**Explanation**
```
žK       # push [a-zA-Z0-9]
  Ç      # convert to list of ascii codes
   IŒ    # push all substrings of input
     Ã   # keep only the subtrings which exist in the list of acsii codes
      g  # push length of resulting list
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~17~~ 13 bytes
```
8Y2"G@oVXf]vn
```
[Try it online!](https://tio.run/nexus/matl#@28RaaTk7pAfFpEWW5b3/7@6qaGhqZmJsaGJoZG5mbGJsToAA "MATL – TIO Nexus") Or [verify all test cases](https://tio.run/nexus/matl#S4jwqvhvEWmk5OWQHxaRFluW998l5L@6qZmlhToXkDIxszQGMYwNLI2MLcxMjAwsDY1MTI0MgYKGEACSNjQEKjU2NDE0MjczNgHrMDO3sATSliYgleoA).
### Explanation
```
8Y2     % Predefined literal: string with all letters, uppercase and lowercase,
        % and digits
"       % For each character in that string
  G     %   Push input, for example the string '5115643141276343'
  @     %   Push current character, such as 'A'
  o     %   Convert to its ASCII code, such as 65
  V     %   String representation, such as '65'
  Xf    %   Find string '65' within string '5115643141276343'. This gives a vector
        %   (possibly empty) with indices of occurrences
]       % End
v       % Concatenate all stack contents vertically
n       % Number of entries. Implicitly display
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 22 bytes
```
∧Ạụ:Ạ:Ịcạ:?{tT&h∋~sT}ᶜ
```
[Try it online!](https://tio.run/nexus/brachylog2#@/@oY/nDXQse7l5qBaSsHu7uSn64a6GVfXVJiFrGo47uuuKQ2ofb5vz/b2poaGpmYmxoYmhkbmZsYvw/CgA "Brachylog – TIO Nexus")
### Explanation
```
       c                 Concatenate together:
∧Ạụ:                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    Ạ:                     "abcdefghijklmnopqrstuvwxyz"
      Ị                    "0123456789"
        ạ                Get the list of ASCII codes of that string
         :?{        }ᶜ   Count the number of results, for input [list of codes, Input], of:
            tT             Call the Input T
              &h∋          Take one ASCII code
                 ~sT       It is a substring of T
```
[Answer]
# Java 8, ~~204~~ ~~197~~ ~~195~~ ~~186~~ 174 bytes
```
n->{int r=0,i=0,e=n.length()-1,t;for(;i<e;r+=t>47&t<57|t>64&t<91|t>96&t<100|(t=new Short(n.substring(i,i++>e-2?i:i+2)))>99&t<123?1:0)t=new Byte(n.substring(i,i+2));return r;}
```
-9 bytes thanks to *@ceilingcat*.
[Try it online.](https://tio.run/##jVBBb8IgGL37K8gOS0ltUyi2IrYmu8@Lx2UHrKi4Sg396mK0v72j6m3JOhLI4@O9j/e@gzzL4LD56opS1jV6l9pcRwhpA8puZaHQsr/eC6jwVmC12SGDhSu2I3fUIEEXaIkMyjoT5NeeaLNorN1WmQlLZXaw93BAxiC2lfWEnith/Qxylr7CfJLeIE@YQ5w4xBOHSBTdPMiM@karfWXBM2HdrOv7554ea9/PVUAXeqZ9ijHOOe9FNF6QWYQfurcLqF8yRxZWQWMNsqLtRB/g1KxLF@CZ41zpDTq6ITyjfnwiiR8TWF1qUMewaiA8uScojetfeC@ThE9f8H0if5FYwuNhWhxxGk8TRiNOKJtQMighjzXcmhBnIiaM0DSJ2T@8JOmUD7I4G3b4ZLSjtvsB)
**Explanation:**
```
n->{                   // Method with String parameter and integer return-type
  int r=0,             //  Result, starting at 0
      i=0,             //  Index
      e=n.length()-1,  //  Length of String -1
      t;               //  Temp integer
  for(;i<e             //  Loop over the String using the index
      ;                //    After every iteration:
       r+=             //     Increase the result-sum by:
          t>47&t<57|t>64&t<91|t>96&t<100
                       //      If two adjacent digits are a digit or letter
          |            //      or
          (t=new Short(n.substring(i,i++>e-2?i:i+2)))>99&t<123?
                       //      if three adjacent digits are a letter:
           1           //       Increase the sum by 1
          :            //      Else:
           0)          //       Keep the sum the same by adding 0
    t=new Byte(n.substring(i,i+2));
                       //   Set `t` to the substring of [i, i+2) converted to integer
  return r;}           //  Return the result-sum
```
[Answer]
## JavaScript (ES6), ~~71~~ 70 bytes
```
f=([a,...b])=>a?(a&(a+=b[0])+b[1]<123|a>47&a<58|a>64&a<91|a>96)+f(b):0
```
### Test cases
```
f=([a,...b])=>a?(a&(a+=b[0])+b[1]<123|a>47&a<58|a>64&a<91|a>96)+f(b):0
console.log(f("5698"))                // 3
console.log(f("564693"))              // 2
console.log(f("530923864209124521"))  // 3
console.log(f("1111111"))             // 5
console.log(f("5115643141276343"))    // 4
console.log(f("56789"))               // 4
console.log(f("94"))                  // 0
console.log(f("1"))                   // 0
```
[Answer]
# [Perl 5](https://www.perl.org/), 47 bytes
46 bytes of code + `-p` flag.
```
$"="|";$_=()=/(?=@{[48..57,65..90,97..122]})/g
```
[Try it online!](https://tio.run/nexus/perl5#JcrLCoJAFADQ/XzFbXShYKN33hcZ6j8qxMjCkBKzRVTfPgmd9UlWYzcNsB5jygP/8DptQpaHMtuE7XunvRDGFdYIQVVBTgiU8vDNy0usIW1ABOD7G4cErs/HDOf7BFPXntpjP/TzKxpLnhmrLSlmVEVSeatlRSi1kcjwjxnEJSnUKJ1VernWeWKkGf4A "Perl 5 – TIO Nexus")
I couldn't find any shorter way to write that `48..57,65..90,97..122`: `map{ord}0..9,a..z,A..Z` (getting the ascii value of the characters) is one byte longer. And doing `for$c(0..122){$\+=chr($c)=~/\pl|\d/ for/(?=$c)/g}}{` (looking for all numbers, but keeping only those whose numbers corresponds to the ascii value of letters (`\pl`) or digits (`\d`)) will be 5 bytes longer (note that `\pl|\d` can't be replaced by `\w` as the latter also includes underscores)). 
---
Previous approach (49 bytes):
```
for$@(48..57,65..90,97..122){$\+=()=/(?=$@)/g}}{
```
[Answer]
# PHP, 68 Bytes
```
for(;a&($a=$argn)[$i];)$d+=ctype_alnum(chr($a[$i].$a[++$i]));echo$d;
```
[Online Version](http://sandbox.onlinephpfunctions.com/code/19f8f6270e4f8e1dd7f0db0ffc58f9e559b8a19c)
[Answer]
# JavaScript (ES), ~~165~~ ~~161~~ ~~156~~ ~~154~~ 153 bytes
Yeah, RegEx definitely wasn't the right tool for the job here!
```
n=>[/\d{2}/g,/\d{3}/g].map(e=>eval("while(x=e.exec(n)){a.push(m=x[0]);e.lastIndex-=m.length-1}"),a=[])|a.filter(x=>x>47&x<58|x>64&x<91|x>96&x<123).length
```
---
## Try It
```
f=
n=>[/\d{2}/g,/\d{3}/g].map(e=>eval("while(x=e.exec(n)){a.push(m=x[0]);e.lastIndex-=m.length-1}"),a=[])|a.filter(x=>x>47&x<58|x>64&x<91|x>96&x<123).length
console.log(f(5698))//3
console.log(f(564693))//2
console.log(f(530923864209124521))//3
console.log(f(1111111))//5
console.log(f(5115643141276343))//4
console.log(f(56789))//4
console.log(f(94))//0
console.log(f(1))//0
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 52 bytes
```
&`1[01]\d|12[012]|4[89]|5[0-7]|6[5-9]|[78]\d|9[0789]
```
[Try it online!](https://tio.run/nexus/retina#JYvLDcMwDEPv2iNFLwFM/WxNkCFUAzlkDO/uqihPJN7j8b7u/bqRDfPzLHAVnktzxFyW7exzedpZK/v4KZGtF9zbPAaZq4eQSQuW4cotwGoMwj9kQEkCBXcXLdfrT6GELw "Retina – TIO Nexus") (includes test suite)
[Answer]
# Pyth, ~~19~~ ~~17~~ 14 bytes
```
l@jGUTmr0Csd.:
```
takes a string.
*-3 Bytes thanks to @LeakyNun*
[Try it!](https://pyth.herokuapp.com/?code=l%40jGUTmr0Csd.%3A&input=%225698%22&test_suite=1&test_suite_input=%225698%22%0A%22564693%22%0A%22530923864209124521%22%0A%221111111%22%0A%225115643141276343%22%0A%2256789%22%0A%2294%22%0A%221%22&debug=0)
### Explanation
```
l@jGUTmr0Csd.:
    UT                # the list of digits [0,1,2,...,9]
  jG                  # join that on the lowercase alphabet (repetition doesn't matter)
              Q       # implicit input
            .:        # all substrings of the input
      m               # for each of those substrings
          sd          # Convert the string to a base 10 integer
         C            # convert that integer to the character with that number
       r0             # make that character lowercase
l@                    # length of the intersection of those two list of chars we generated
 
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~74~~ ~~64~~ 62 bytes
```
f=lambda n:n and chr(n%10**(3-(n%1000>122))).isalnum()+f(n/10)
```
[Try it online!](https://tio.run/nexus/python2#JY3BDsIgEETP@hV7IYVKlV0ohSb2X1DS2KRdTdXvr6hzmJlkXjLbeJ7TcskJuGdInOF6WyULNHUtbfNrxgxIpJQ6Ts8083uR6jBKPqFR23hfgWFiaH0Murjz0Za0JpIN3pGJSK4l1IB/lRGxcBYdUuet@@K@C1FDdIXq97vHOvELKoEhQzOAyBUIkKyhvCq1fQA "Python 2 – TIO Nexus")
[Answer]
# Haskell, ~~161~~ ~~157~~ ~~138~~ ~~129~~ 126 bytes
```
import Data.List
f x=sum[1|y<-nub$concat$words.concat<$>mapM(\c->[[c],c:" "])x,any(elem$read y)[[48..57],[65..90],[97..122]]]
```
I wonder if there is a better way to remove dupes of the list than importing Data.List for nub?
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
ØBODf@ẆL
```
Input is a digit array.
[Try it online!](https://tio.run/nexus/jelly#@394hpO/S5rDw11tPv///zfVMdYx0LHUMQLSFjpmOiZAFohvCKRNdEyBpCEA "Jelly – TIO Nexus")
### How it works
```
ØBODf@ẆL  Main link. Argument: A (digit array)
ØB        Base 62; yield all alphanumeric ASCII characters.
  O       Ordinal; get their code points.
   D      Decimal; convert the code points into digit arrays.
      Ẇ   Window; yield all contiguous subarrays of A.
    f@    Filter swapped; keep all elements of the result to the right that appear
          in the result to the left.
       L  Length; count the matches.
```
[Answer]
# Ruby, 50 bytes
```
p (0..~/$/).any?{|n|$_[n,2].to_i.chr=~/\p{Alnum}/}
```
Reads from standard input; requires the Ruby interpreter be invoked with the `-n` option (implicit `while gets` loop).
Could be reduced to 43 bytes if it were allowed to match underscores.
```
p (0..~/$/).any?{|n|$_[n,2].to_i.chr=~/\w/}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 24 bytes
```
;è"(?={9ò ¬+B+C ¬mc q|})
```
[Try it online!](https://tio.run/nexus/japt#@299eIWShr1tteXhTQqH1mg7aTsDqdxkhcKaWs3//5VMjQ0sjYwtzEyMDCwNjUxMjQyVAA "Japt – TIO Nexus")
Alternate 27-byte version:
```
è"(?={#~o f_d f"%d|%l"Ãq|})
```
[Try it online!](https://tio.run/nexus/japt#@394hZKGvW21cl2@Qlp8ikKakmpKjWqO0uHmwppazf//lUyNDSyNjC3MTIwMLA2NTEyNDJUA "Japt – TIO Nexus")
]