编辑：如果您正在使用Lisp，我在计数字节的底部给出了一些准则。

目标：做最短的函数，将一个字符串拆分为非数字，并返回每个字符串中仅包含数字的数组，而无需使用任何正则表达式。每个字符串中应包含前导零。

当前排名（按类别划分）：

• C / C ++ / C＃/ Java： 68（C）...。
• GolfScript / APL / J： 13（APL）
• 所有其他： 17（重击，使用tr），24（红宝石）

规则：

（冗长的道歉）

1. 格式必须是带有单个字符串参数的函数。如果需要正确返回数组，最多可以添加两个附加参数（例如，sh / csh / DOS Batch需要一个额外的变量引用才能返回等）。
2. 主要函数声明不计算在内，也不会导入其他标准库。“ #include”，“ import”和“ using”不计算在内。其他一切都做。这确实包括#define和辅助函数。对困惑感到抱歉。将此作为有用的指南，以了解哪些内容不算（用C样式语法编写）

   //不计入总数，除非可以省略
   //不明显，就像Java标准库的一半一样。
   #include <stdio.h>
   
   import some.builtin.Class //不算，见上文
   
   #define printf p //计入总数
   
   / *任何其他预处理指令等。* /
   
   int i = 0; //计数
   
   someFunction（）; //计数
   
   char [] [] myMainSplitFunction（char [] [] array）{//不计算在内
     //这里的一切都很重要
     return returnArray; //即使这很重要。
   } //不算在内
   
   / *此处的所有内容都很重要，包括声明* /
   char [] [] someHelperFunction（char [] string）{
     // 东西
   } //即使如此
   

3. 输出必须是字符串数组或类似的字符串（可接受Java和类似的数组列表）。接受的输出的示例：String[]，char[][]，Array，List，和Array（对象）。
4. 该数组必须仅包含可变长度的字符串基元或字符串对象。返回中不得包含空字符串，但以下情况除外。注意：字符串包含连续匹配的字符串，例如下面的示例输入和输出。
5. 如果没有匹配项，则函数主体应返回null，空数组/列表或包含空字符串的数组/列表。
6. 不允许外部库。
7. DOS行尾计为一个字节，而不是两个字节（已经在meta中覆盖，但需要强调）
8. 这是最大的规则：不允许使用正则表达式。

这是一个代码高尔夫球问题，因此以最小的大小为准。祝好运！

以下是一些示例输入和输出（带有C型转义符）：

输入：“ abc123def456”
输出：[“ 123”，“ 456”]

输入：“ aitew034snk582：3c”
输出：[“ 034”，“ 582”，“ 3”]

输入：“ as5493tax54 \\ 430-52@g9.fc”
输出：[“ 5493”，“ 54”，“ 430”，“ 52”，“ 9”]

输入：“ sasprs] tore \“ re \\ forz”
输出：null，[]，[“”]或类似内容

请输入答案使用的字节数，一如既往地快乐打高尔夫球！

Lisp准则

以下是Lisp方言中的计算和不计算的内容：

;;; 选项1

（defun extract-strings（ab）;不算
  （东西） ;;; 这里的一切都很重要
）; 不算

;;; 选项2

（defun extract-strings（字符串＆aux（开始0）（结束0））;不计算
  （东西） ;;; 这里的一切都很重要
）; 不算在内。

APL，13个字符

（或28/30字节，请阅读下文）

{⍵⊂⍨⍵∊∊⍕¨⍳10}

我们看到您已禁止GolfScript提出您的问题。我理解您的想法，但我希望这个社区最终不会禁止APL，因为它是源远流长的真正杰出的编程语言，更不用说编写代码了很多乐趣。如果有人说，它的得分可能会有所不同感到竞争不公平。我会将对此事的想法发布到您链接的那个线程上。

同样，我一直在APL帖子中添加脚注，声称APL可以得分为1个字符= 1个字节。我的主张基于这样一个事实，即少数（大多数为商业用途）APL实现仍支持其自己的旧式单字节编码，并且APL符号映射到高128字节的值。但这可能太麻烦了，在这种情况下，您可能希望将此条目的得分记为UTF-16中的28个字节或UTF-8中的30个字节。

说明

{        ⍳10}  make an array of naturals from 1 to 10
       ⍕¨      convert each number into a string
      ∊        concatenate the strings into one (it doesn't matter that there are two 1s)
    ⍵∊         test which chars from the argument are contained in the digit string
 ⍵⊂⍨           use it to perform a partitioned enclose, which splits the string as needed

例子

      {⍵⊂⍨⍵∊∊⍕¨⍳10} 'ab5c0x'
 5  0 
      {⍵⊂⍨⍵∊∊⍕¨⍳10}  'z526ks4f.;8]\p'
 526  4  8 

字符串数组的默认输出格式无法清楚说明该数组中有多少个字符串，也没有空白。但是快速添加引号的操作应该足够清楚：

      {q,⍵,q←'"'}¨ {⍵⊂⍨⍵∊∊⍕¨⍳10} 'ab5c0x'
 "5"  "0" 
      {q,⍵,q←'"'}¨ {⍵⊂⍨⍵∊∊⍕¨⍳10}  'z526ks4f.;8]\p'
 "526"  "4"  "8" 

Python 47

实作

f=lambda s:"".join([' ',e][e.isdigit()]for e in s).split()

演示版

>>> sample=["abc123def456","aitew034snk582:3c","as5493tax54\\430-52@g9.fc","sasprs]tore\"re\\forz"]
>>> [f(data) for data in sample]
[['123', '456'], ['034', '582', '3'], ['5493', '54', '430', '52', '9'], []]

算法

将每个非数字字符转换为空格，然后分割结果字符串。一种简单明了的方法。

使用itertools的有趣解决方案（71个字符）

f1=lambda s:[''.join(v)for k,v in __import__("itertools").groupby(s,key=str.isdigit)][::2]

Ruby，70岁

f=->(s){s.chars.chunk{|c|c.to_i.to_s==c}.select{|e|e[0]}.transpose[1]}

在线版本进行测试

由于将任何非数字字符转换为int会在Ruby中返回0（使用to_i），因此将每个char转换为int然后再转换回char是检查数字的非正则表达式方式...

bash，26（函数内容：22 +数组分配开销4）

这不会超越其他bash答案，但它很有趣，因为它可能使您倍加注意：

f()(echo ${1//+([!0-9])/ })

用法是：

$ a=(`f "ab5c0x"`); echo ${a[@]}
5 0
$ a=(`f "z526ks4f.;8]\p"`); echo ${a[@]}
526 4 8
$ 

乍一看，//+([!0-9])/看起来很像是regexp替代，但事实并非如此。这是一个bash参数扩展，它遵循模式匹配规则，而不是正则表达式规则。

从bash函数返回真正的bash数组类型很痛苦，因此我选择返回一个以空格分隔的列表，然后在函数调用之外的数组分配中转换为数组。因此，为了公平起见，我认为(` `)函数调用周围应包含在我的分数中。

Mathematica 32

StringCases[#,DigitCharacter..]&

用法

inps ={"abc123def456", "aitew034snk582:3c", "as5493tax54\\430-52@g9.fc", 
        "sasprs]tore\"re\\forz"}  
StringCases[#,DigitCharacter..]&/@inps

{{"123", "456"}, 
 {"034", "582", "3"}, 
 {"5493", "54", "430", "52", "9"}, 
 {}
}

使用正则表达式的等效时间更长！

StringCases[#, RegularExpression["[0-9]+"]] &

Bash，21字节 17/21字节（由DigitalTrauma改进）

使用空格建立以空格分隔的列表 tr

function split() {
tr -c 0-9 \ <<E
$1
E
}

用空格替换任何非数字

用法

$ for N in $(split 'abc123def456'); do echo $N; done
123
456

编辑

正如下面的注释所指出的那样，该代码可以精简为17个字节：

function split() (tr -c 0-9 \ <<<$1)

由于结果严格来说不是Bash数组，因此用法应为

a=(`split "abc123def456"`); echo ${a[@]}

多余的(``)应该算在内

Smalltalk（Smalltalk / X），81

f := [:s|s asCollectionOfSubCollectionsSeparatedByAnyForWhich:[:ch|ch isDigit not]]

f值：'abc123def456'-> OrderedCollection（'123''456'）

f值：'aitew034snk582：3c'-> OrderedCollection（'034''582''3'）

f值：'as5493tax54 \ 430-52@g9.fc'-> OrderedCollection（'5493''54''430''52''9'）

f值：'sasprs] tore \“ re \ forz'-> OrderedCollection（）

感叹-Smalltalk倾向于使用veeeery长函数名...

R，81

f=function(x){
s=strsplit(x,"",T)[[1]]
i=s%in%0:9
split(s,c(0,cumsum(!!diff(i))))[c(i[1],!i[1])]
}

该函数接受一个字符串并返回一个字符串列表。

例子：

> f("abc123def456")
$`1`
[1] "1" "2" "3"

$`3`
[1] "4" "5" "6"

--

> f("aitew034snk582:3c")
$`1`
[1] "0" "3" "4"

$`3`
[1] "5" "8" "2"

$`5`
[1] "3"

--

> f("as5493tax54\\430-52@g9.fc")
$`1`
[1] "5" "4" "9" "3"

$`3`
[1] "5" "4"

$`5`
[1] "4" "3" "0"

$`7`
[1] "5" "2"

$`9`
[1] "9"

--

> f("sasprs]tore\"re\\forz")
$<NA>
NULL

注意：$x是列表元素的名称。

Perl，53岁

编辑：在没有匹配项的情况下，sub现在根据需要返回带有空字符串的列表（而不是空列表）。

它还避免了在单个空格字符上拆分，因为它会触发“在任何空格上拆分”行为，这可能违反了规则。我可以使用/ /定界符，该定界符将在单个空间上分割，但自相矛盾的是，它看起来像使用regexp模式。我可以用unpack一些额外的字符作为代价，因此split完全消除了争议，但是我认为，最后，拆分一个文字字符（而不是空格）是可以的。

sub f{shift if(@_=split a,pop=~y/0-9/a/csr)[0]eq''and$#_;@_}

而且，不，Perl的音译运算符不执行正则表达式。0123456789如果这是问题，我可以将0-9范围展开。

C，68个字节（仅函数体）

void split (char *s, char **a) {
int c=1;for(;*s;s++)if(isdigit(*s))c?*a++=s:0,c=0;else*s=0,c=1;*a=0;
}

第一个参数是输入字符串，第二个参数是输出数组，它是一个以NULL结尾的字符串数组。必须保留足够的内存用于a在调用该函数之前，（最坏的情况：）sizeof(char*)*((strlen(s)+1)/2)。

输入字符串由函数修改（每个非数字字符均替换为 '\0'）

使用范例

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

void split (char *s, char **a) {
int c=1;for(;*s;s++)if(isdigit(*s))c?*a++=s:0,c=0;else*s=0,c=1;*a=0;
}   

void dump(char **t) {
    printf("[ ");for(;*t;t++)printf("%s ", *t);printf("]\n");
}   

int main() {
    char **r = malloc(1024);
    char test1[] = "abc123def456";
    char test2[] = "aitew034snk582:3c";
    char test3[] = "as5493tax54\\430-52@g9.fc";
    char test4[] = "sasprs]tore\"re\\forz";
    split(test1,r); 
    dump(r);
    split(test2,r); 
    dump(r);
    split(test3,r); 
    dump(r);
    split(test4,r); 
    dump(r);
    return 0;
}

输出量

[ 123 456 ]
[ 034 582 3 ]
[ 5493 54 430 52 9 ]
[ ]

非高尔夫版本：

void split (char *s, char **a) {
    int c=1; // boolean: the latest examined character is not a digit
    for(;*s;s++) {
        if(isdigit(*s)) {
            if(c) *a++ = s; // stores the address of the beginning of a digit sequence
            c=0;
        } else {
            *s=0; // NULL-terminate the digit sequence
            c=1;
        }   
    }   
    *a = 0; // NULL-terminate the result array
} 

VBScript，190（164，不带函数声明）

Function f(i)
For x=1 To Len(i)
c=Mid(i,x,1)
If Not IsNumeric(c) Then
Mid(i,x,1)=" "
End If
Next
Do
l=Len(i)
i=Replace(i,"  "," ")
l=l-Len(i)
Loop Until l=0
f=Split(Trim(i)," ")
End Function

尽管完全没有竞争力，但令我惊讶的是，鉴于它的详细程度，VBScript如此简短（仅CR就有13个字节）。它循环遍历字符串，用空格替换所有非数字字符，然后将所有空格减少为单个空格，然后使用空格定界符对其进行分割。

测试用例

Input: "ab5c0x"
Output: 5,0

Input: "z526ks4f.;8]\p"
Output: 526,4,8

普通Lisp（根据字母1个;根据精神≈173）

这是可读的版本。由于诸如digit-char-pand position-if和的长名称，因此字节数相当高vector-push-extend。

(defun extract-numeric-substrings (string &aux (start 0) (end 0) (result (make-array 0 :adjustable t :fill-pointer 0)))
  (loop 
     (unless (and end (setq start (position-if #'digit-char-p string :start end)))
       (return result))
     (setq end (position-if (complement #'digit-char-p) string :start (1+ start)))
     (vector-push-extend (subseq string start end) result)))

(extract-numeric-substrings "abc123def456")
#("123" "456")

(extract-numeric-substrings "aitew034snk582:3c")
#("034" "582" "3")

(extract-numeric-substrings "as5493tax54\\430-52@g9.fc")
#("5493" "54" "430" "52" "9")

(extract-numeric-substrings "sasprs]tore\"re\\forz")
#()

“函数声明”的概念有点模糊。这是一个只有一个字节（x函数主体中的字符）的版本；其他所有内容都捆绑在该函数的lamba列表（该函数的声明的一部分）的辅助变量中：

(defun extract-numeric-substrings (string 
                                   &aux (start 0) (end 0) 
                                   (result (make-array 0 :adjustable t :fill-pointer 0))
                                   (x (loop 
                                         (unless (and end (setq start (position-if #'digit-char-p string :start end)))
                                           (return result))
                                         (setq end (position-if (complement #'digit-char-p) string :start (1+ start)))
                                         (vector-push-extend (subseq string start end) result))))
  x)

实际的字节数将取决于必须将多少个辅助声明移入主体才能被接受。某些局部功能重命名也将有所帮助（例如，缩短position-if两次，因为它出现两次，使用单字母变量，等等）。

该程序的呈现具有220个字符：

(LOOP(UNLESS(AND END(SETQ START(POSITION-IF #'DIGIT-CHAR-P STRING :START END)))(RETURN RESULT))(SETQ END(POSITION-IF(COMPLEMENT #'DIGIT-CHAR-P)STRING :START(1+ START)))(VECTOR-PUSH-EXTEND(SUBSEQ STRING START END)RESULT))

如果没什么，这应该促进Common Lisp的＆aux变量。

loop当然，这可以用以下代码更简洁地编写：

(defun extract-numeric-substrings (s &aux (b 0) (e 0) (r (make-array 0 :fill-pointer 0)))
  (loop 
     with d = #'digit-char-p 
     while (and e (setq b (position-if d s :start e)))
     finally (return r)
     do 
       (setq e (position-if-not d s :start (1+ b)))
       (vector-push-extend (subseq s b e) r)))

的loop形式，额外的空间删除，有173个字符：

(LOOP WITH D = #'DIGIT-CHAR-P WHILE(AND E(SETQ B(POSITION-IF D S :START E)))FINALLY(RETURN R)DO(SETQ E(POSITION-IF-NOT D S :START(1+ B)))(VECTOR-PUSH-EXTEND(SUBSEQ S B E)R))

JavaScript，240个字节

对于那些好奇的人来说，这可能是我的超级高尔夫：

function split(a) { // begin function
function f(c){for(var a=-1,d=9;d--;){var e=c.indexOf(d+"");0
>e||e<a&&(a=e)}return 0<a?a:null}var c=f(a);if(null==c)retur
n null;var d=[];for(i=0;;){a=a.substring(c);d[i]||(d[i]="");
c=f(a);if(null==c)break;d[i]+=a.charAt(c);0<c&&i++}return d;
} // end function

上面漂亮的印刷品：

function split(a) {
    function f(c) {
        for (var a = -1, d = 9;d--;) {
            var e = c.indexOf(d + "");
            0 > e || e < a && (a = e);
        }
        return 0 < a ? a : null;
    }
    var c = f(a);
    if (null == c) return null;
    var d = [];
    for (i = 0;;) {
        a = a.substring(c);
        d[i] || (d[i] = "");
        c = f(a);
        if (null == c) break;
        d[i] += a.charAt(c);
        0 < c && i++;
    }
    return d;
}

上面的普通描述性代码

function split(a) {
    function findLoop(string) {
        var lowest = -1;
        var i = 9;
        while (i--) {
            var index = string.indexOf(i + '');
            if (index < 0) continue;
            if (index < lowest) lowest = index;
        }
        return (lowest > 0) ? lowest : null;
    }
    var index = findLoop(a);
    if (index == null) return null;
    var ret = [];
    i = 0;
    for ( ; ; ) {
        a = a.substring(index);
        if (!ret[i]) ret[i] = '';
        index = findLoop(a);
        if (index == null) break;
        ret[i] += a.charAt(index);
        if (index > 0) i++;
    }
    return ret;
}

PHP 134

function f($a){
$i=0;while($i<strlen($a)){!is_numeric($a[$i])&&$a[$i]='-';$i++;}return array_filter(explode('-',$a),function($v){return!empty($v);});
}

C，158

#define p printf
char s[100],c;int z,i;int main(){while(c=getchar())s[z++]=(c>47&&c<58)*c;p("[");for(;i<z;i++)if(s[i]){p("\"");while(s[i])p("%c",s[i++]);p("\",");}p("]");}

由于C没有内置的数组打印功能，因此我必须自己完成这项工作，因此我很抱歉每个输出中都有一个逗号结尾。从本质上讲，该代码的作用是读取字符串，如果不是数字，则将其替换为'\ 0'，然后循环浏览代码并打印出所有数字链。（EOF = 0）

输入：ab5c0x
输出：[“ 5”，“ 0”，]

输入：z526ks4f。; 8] \ p
输出：[“ 526”，“ 4”，“ 8”，]

C＃，98

static string[] SplitAtNonDigits(string s)
{
    return new string(s.Select(c=>47<c&c<58?c:',').ToArray()).Split(new[]{','},(StringSplitOptions)1);
}

首先，这使用LINQ .Select()扩展方法将所有非数字转换为逗号。string.Replace()会更可取，因为它返回a string而不是a IEnumerable<char>，但是string.Replace()只能使用单个char或字符串，而不能使用诸如char.IsDigit() or47<c&c<58。

如前所述，.Select()应用于字符串会返回一个IEnumerable<char>，因此我们需要将其转换为字符串，方法是将其转换为数组并将该数组传递给string构造函数。

最后，我们使用分割逗号string.Split()。(StringSplitOptions)1是一种简短的说法StringSplitOptions.RemoveEmptyEntries，它将自动处理多个连续的逗号和字符串开头/结尾的逗号。

JS /节点：168 162 147 138个字符

function n(s){
var r=[];s.split('').reduce(function(p,c){if(!isNaN(parseInt(c))){if(p)r.push([]);r[r.length-1].push(c);return 0;}return 1;},1);return r;
}

美化版本：

function n(s) {
  var r = [];
  s.split('').reduce(function (p, c) {
    if (!isNaN(parseInt(c))) {
      if (p) {
        r.push([]);
      }
      r[r.length - 1].push(c);
      return 0;
    }
    return 1;
  }, 1);
  return r;
}

Ruby，24岁

f=->s{s.tr("
-/:-~",' ').split}

使用可打印ascii范围内的负空格定义数字。

PHP， 204

function s($x){$a=str_split($x);$c=-1;$o=array();
for($i= 0;$i<count($a);$i++){if(ord($a[$i])>=48&&ord($a[$i])<=57)
{$c++;$o[$c]=array();}while(ord($a[$i])>=48&&ord($a[$i])<=57)
{array_push($o[$c],$a[$i]);$i++;}}return $o;}

描述代码：

function splitdigits($input){

    $arr = str_split($input);
    $count = -1;
    $output = array();
    for($i = 0; $i < count($arr); $i++){


    if(ord($arr[$i]) >= 48 && ord($arr[$i]) <= 57){
        $count++;
        $output[$count] = array();
    }

    while(ord($arr[$i]) >= 48 && ord($arr[$i]) <= 57){
        array_push($output[$count], $arr[$i]);
        $i++;
    } 

}

return $output;
}

这是很长的代码，我相信此代码高尔夫将有一个更短的php版本。这是我可以在php中提出的。

蟒蛇

def find_digits(_input_):
    a,b = [], ""
    for i in list(_input_):
        if i.isdigit(): b += i
        else:
            if b != "": a.append(b)
            b = ""
    if b != "": a.append(b)
    return a

Python 104 83

def f(s, o=[], c=""):
    for i in s:
        try:int(i);c+=i
        except:o+=[c];c=""
    return [i for i in o+[c] if i]

@Abhijit的答案非常聪明，这只是我所想到的“最小化”版本。

assert f("abc123def456") == ["123", "456"]
assert f("aitew034snk582:3c") == ["034", "582", "3"]
assert f("as5493tax54\\430-52@g9.fc") == ["5493", "54", "430", "52", "9"]
assert f("sasprs]tore\"re\\forz") == []

这不会产生任何输出，因此，如果在声明中定义了一些变量，则代码如果一一运行就可以正常工作。

PHP 98 89

就像DigitalTrauma的bash答案一样，它不使用正则表达式。

function f($x) {
// Only the following line counts:
for($h=$i=0;sscanf(substr("a$x",$h+=$i),"%[^0-9]%[0-9]%n",$j,$s,$i)>1;)$a[]=$s;return@$a;
}

测试用例：

php > echo json_encode(f("abc123def456")), "\n";
["123","456"]
php > echo json_encode(f("aitew034snk582:3c")), "\n";
["034","582","3"]
php > echo json_encode(f("as5493tax54\\430-52@g9.fc")), "\n";
["5493","54","430","52","9"]
php > echo json_encode(f("sasprs]tore\"re\\forz")), "\n";
null

哈斯克尔31

{-# LANGUAGE OverloadedStrings #-}
import Data.Char (isDigit)
import Data.Text (split)

f=filter(/="").split(not.isDigit)

它将字符串拆分为所有非数字字符，并删除由连续定界符生成的空字符串。

没有功能声明的VBA 210、181

Function t(s)
Dim o()
For Each c In Split(StrConv(s,64),Chr(0))
d=IsNumeric(c)
If b And d Then
n=n&c
ElseIf d Then:ReDim Preserve o(l):b=1:n=c
ElseIf b Then:b=0:o(l)=n:l=l+1:End If:Next:t=o
End Function

Rebol（66个字符）

remove-each n s: split s complement charset"0123456789"[empty? n]s

解开并包装在函数声明中：

f: func [s] [
    remove-each n s: split s complement charset "0123456789" [empty? n]
    s
]

Rebol控制台中的示例代码：

>> f "abc123def456"
== ["123" "456"]

>> f "aitew035snk582:3c"
== ["035" "582" "3"]

>> f "as5493tax54\\430-52@g9.fc"
== ["5493" "54" "430" "52" "9"]

>> f {sasprs]torer"re\\forz}
== []

JavaScript，104 97 89

打高尔夫球：

编辑：当循环走出数组的末尾时，c是undefined，这是虚假的并终止循环。

2/27：使用?:可以节省的冗长性if/else。

function nums(s) {
s+=l='length';r=[''];for(k=i=0;c=s[i];i++)r[k]+=+c+1?c:r[k+=!!r[k][l]]='';
r[l]--;return r
}

车厢内的回车是为了便于阅读，而不是解决方案的一部分。

取消高尔夫：

想法是将每个字符（如果是数字）追加到数组的最后一个条目，否则确保最后一个数组的条目是字符串。

function nums(s) {
    var i, e, r, c, k;
    k = 0;
    s+='x'; // ensure the input does not end with a digit
    r=[''];
    for (i=0;i<s.length;i++) {
        c=s[i];
        if (+c+1) { // if the current character is a digit, append it to the last entry
            r[k] += c;
        }
        else { // otherwise, add a new entry if the last entry is not blank
            k+=!!r[k].length;
            r[k] = '';
        }
    }
    r.length--; // strip the last entry, known to be blank
    return r;
}

Javascript，72

function f(a){
 a+=".",b="",c=[];for(i in a)b=+a[i]+1?b+a[i]:b?(c.push(b),""):b;return c
}

不打高尔夫球

a+=".",b="",c=[];        //add '.' to input so we dont have to check if it ends in a digit
for(i in a)
    b=+a[i]+1?           //check if digit, add to string if it is
        b+a[i]:         
    b?                   //if it wasnt a digit and b contains digits push it
        (c.push(b),""):  //into the array c and clear b
    b;                   //else give me b back
return c

样本输入/输出

console.log(f("abc123def456"));
console.log(f("aitew034snk582:3c"));
console.log(f("as5493tax54\\430-52@g9.fc"));
console.log(f("sasprs]tore\"re\\forz"));

["123", "456"]
["034", "582", "3"]
["5493", "54", "430", "52", "9"]
[] 

JSFiddle

R 52

此函数按字符类（不是regex！：:）拆分字符串。类为N-数字字符，P {N}表示否定该类。o = T表示省略空子字符串。

x
## [1] "wNEKbS0q7hAXRVCF6I4S" "DpqW50YfaDMURB8micYd" "gwSuYstMGi8H7gDAoHJu"
require(stringi)
stri_split_charclass(x,"\\P{N}",o=T)
## [[1]]
## [1] "0" "7" "6" "4"

## [[2]]
## [1] "50" "8" 

## [[3]]
## [1] "8" "7"

PHP 99

<?php

$a = function($s) {
foreach(str_split($s)as$c)$b[]=is_numeric($c)?$c:".";return array_filter(explode('.',implode($b)));
};

var_dump($a("abc123def456"));
var_dump($a("aitew034snk582:3c"));
var_dump($a("as5493tax54\\430-52@g9.fc"));
var_dump($a("sasprs]tore\"re\\forz"));

输出量

array(2) {
  [3]=>
  string(3) "123"
  [6]=>
  string(3) "456"
}
array(3) {
  [5]=>
  string(3) "034"
  [8]=>
  string(3) "582"
  [9]=>
  string(1) "3"
}
array(5) {
  [2]=>
  string(4) "5493"
  [5]=>
  string(2) "54"
  [6]=>
  string(3) "430"
  [7]=>
  string(2) "52"
  [9]=>
  string(1) "9"
}
array(0) {
}

JavaScript的88

不计算函数n（x）{}时为88个字符

function n(x){
y=[],i=0,z=t=''
while(z=x[i++])t=!isNaN(z)?t+z:t&&y.push(t)?'':t
if(t)y.push(t)
return y
}