Die alphanumerischen Zeichen haben ASCII-Werte:

0-9  ->  48-57
A-Z  ->  65-90
a-z  ->  97-122

Ihre Herausforderung besteht darin, eine Ganzzahl als Eingabe zu verwenden und auszugeben, wie viele Zeichen mit aufeinanderfolgenden Ziffern dieser Zahl erstellt werden können. Die Zeichencodes können sich überlappen. 666sollte ergeben 2, da du 66zweimal hast .

Testfälle:

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

Eingabe- und Ausgabeformate sind optional (ja, Sie können die Ganzzahl als Zeichenfolge verwenden).

05AB1E , 8 7 Bytes

žKÇIŒÃg

Probieren Sie es online!

Erläuterung

ž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

Brachylog , 22 Bytes

∧Ạụ:Ạ:Ịcạ:?{tT&h∋~sT}ᶜ

Probieren Sie es online!

Erläuterung

       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

MATL , 17 13 Bytes

8Y2"G@oVXf]vn

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Java 7, 204 197 195 Bytes

int c(String n){int r=0,i=0,e=n.length()-1,t;for(;i<e;r+=((t=new Byte(n.substring(i,i+2)))>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);return r;}

Erläuterung:

int c(String n){       // Method with String parameter and integer return-type
  int r=0,             //  Result
      i=0,             //  Index
      e=n.length()-1,  //  Length of String -1
      t;               //  Temp integer
  for(;i<e;            //  Loop over the String using the index
    r+=                //   Append the result-sum with:
      ((t=new Byte(n.substring(i,i+2)))>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               //     Raise the sum by 1
      :                //    Else:
       0               //     Keep the sum the same (by adding 0)
  );                   //  End of loop (implicit / no body)
  return r;            //  Return result
}                      // End of method

Testcode:

Probieren Sie es hier aus.

class M{
  static int c(String n){int r=0,i=0,e=n.length()-1,t;for(;i<e;r+=((t=new Byte(n.substring(i,i+2)))>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);return r;}

  public static void main(String[] a){
    System.out.println(c("5698"));
    System.out.println(c("564693"));
    System.out.println(c("530923864209124521"));
    System.out.println(c("1111111"));
    System.out.println(c("5115643141276343"));
    System.out.println(c("56789"));
    System.out.println(c("94"));
    System.out.println(c("1"));
  }
}

JavaScript (ES6), 71-70 Byte

f=([a,...b])=>a?(a&(a+=b[0])+b[1]<123|a>47&a<58|a>64&a<91|a>96)+f(b):0

Testfälle

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

Perl 5 , 47 Bytes

46 Byte Code + -pFlag.

$"="|";$_=()=/(?=@{[48..57,65..90,97..122]})/g

Probieren Sie es online!

Ich konnte keinen kürzeren Weg finden, um Folgendes zu schreiben 48..57,65..90,97..122: map{ord}0..9,a..z,A..Z(Ermittelt den ASCII-Wert der Zeichen) Ist ein Byte länger. Und dabei for$c(0..122){$\+=chr($c)=~/\pl|\d/ for/(?=$c)/g}}{(nach allen Zahlen suchen, aber nur diejenigen behalten, deren Zahlen dem ASCII-Wert von Buchstaben ( \pl) oder Ziffern ( \d) entsprechen), sind 5 Byte länger (Anmerkung, \pl|\ddie nicht durch ersetzt werden kann, \wda letztere auch Unterstriche enthalten). .

Bisheriger Ansatz (49 Byte):

for$@(48..57,65..90,97..122){$\+=()=/(?=$@)/g}}{

PHP, 68 Bytes

for(;a&($a=$argn)[$i];)$d+=ctype_alnum(chr($a[$i].$a[++$i]));echo$d;

Online Version

JavaScript (ES), 165 161 156 154 153 Byte

Ja, RegEx war definitiv nicht das richtige Werkzeug für den Job hier!

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

Versuch es

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

Netzhaut , 52 Bytes

&`1[01]\d|12[012]|4[89]|5[0-7]|6[5-9]|[78]\d|9[0789]

Probieren Sie es online! (beinhaltet Testsuite)

Python 2 , 74 64 62 Bytes

f=lambda n:n and chr(n%10**(3-(n%1000>122))).isalnum()+f(n/10)

Probieren Sie es online!

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]]]

Ich frage mich, ob es einen besseren Weg gibt, um Dupes aus der Liste zu entfernen, als Data.List for Nub zu importieren.

Pyth, 19 17 14 Bytes

l@jGUTmr0Csd.:

nimmt eine Zeichenfolge.

-3 Bytes dank @LeakyNun

Versuch es!

Erläuterung

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

Gelee , 8 Bytes

ØBODf@ẆL

Die Eingabe ist ein Ziffernfeld.

Probieren Sie es online!

Wie es funktioniert

Ø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.

Ruby, 50 Bytes

p (0..~/$/).any?{|n|$_[n,2].to_i.chr=~/\p{Alnum}/}

Liest von der Standardeingabe; setzt voraus, dass der Ruby-Interpreter mit dem aufgerufen wird-n Option (implizite while getsSchleife) .

Könnte auf 43 Bytes reduziert werden, wenn es erlaubt wäre, Unterstriche abzugleichen.

p (0..~/$/).any?{|n|$_[n,2].to_i.chr=~/\w/}

Japt , 24 Bytes

;è"(?={9ò ¬+B+C ¬mc q|})

Probieren Sie es online!

Alternative 27-Byte-Version:

è"(?={#~o f_d f"%d|%l"Ãq|})

Probieren Sie es online!