Edição: Se você estiver usando Lisp, eu dei algumas orientações na parte inferior na contagem de bytes.

Objetivo: criar a função mais curta que divide uma sequência em dígitos que não sejam dígitos e retorna uma matriz que consiste apenas em dígitos em cada sequência, sem o uso de expressões regulares. Os zeros à esquerda devem ser incluídos em cada sequência.

Classificação atual (separada em categorias):

• C / C ++ / C # / Java: 68 (C) ....
• GolfScript / APL / J: 13 (APL)
• Todos os outros: 17 (Bash, usos tr), 24 (Ruby)

Regras:

(Peço desculpas pela demora)

1. O formato deve ser uma função com um argumento de cadeia única. Até dois argumentos adicionais podem ser adicionados, se necessário, para o retorno adequado da matriz (por exemplo, sh / csh / DOS Batch precisa de uma referência variável extra para retornar, etc.).
2. A declaração da função principal não conta e nem importa outras bibliotecas padrão. `# include`s,` import`s e `using`s não contam. Tudo o resto faz. Isso inclui as funções # # define`s e helper. Desculpe pela confusão. Consulte este manual como um guia útil sobre o que conta / não conta (escrito na sintaxe no estilo C)

   // não conta para o total, pode ser omitido, a menos
   // não óbvio, como metade da biblioteca padrão do Java.
   #include <stdio.h>
   
   import some.builtin.Class // não conta, veja acima
   
   #define printf p // conta para o total
   
   / * Quaisquer outras diretivas de pré-processador, etc. contam. * /
   
   int i = 0; // conta
   
   someFunction (); // conta
   
   char [] [] myMainSplitFunction (char [] [] array) {// não conta
     // Tudo aqui conta
     return returnArray; // Até isso conta.
   } // não conta
   
   / * Tudo aqui conta, incluindo a declaração * /
   char [] [] someHelperFunction (char [] string) {
     // coisa
   } // mesmo isso conta
   

3. A saída deve ser uma matriz de cadeias ou semelhante (listas de matrizes em Java e similares são aceitáveis). Exemplos de saída aceite: String[], char[][], Array, List, e Array(objecto).
4. A matriz deve conter apenas primitivas de seqüência de caracteres de comprimento variável ou objetos de seqüência de caracteres. Nenhuma string vazia deve estar presente no retorno, com a exceção abaixo. Nota: as sequências devem conter uma sequência de correspondências consecutivas, como o exemplo de entrada e saída abaixo.
5. Se não houver correspondências, o corpo da função deve retornar null, uma matriz / lista vazia ou uma matriz / lista contendo uma sequência vazia.
6. Nenhuma biblioteca externa permitida.
7. As terminações de linha do DOS contam como um byte, não dois (já abordado na meta, mas precisa ser enfatizado)
8. E a maior regra aqui: não são permitidas expressões regulares.

Esta é uma questão de código-golfe , então o menor tamanho vence. Boa sorte!

E aqui estão alguns exemplos de entradas e saídas (com escapamentos no estilo C):

Entrada: "abc123def456"
Saída: ["123", "456"]

Entrada: "aitew034snk582: 3c"
Saída: ["034", "582", "3"]

Entrada: "as5493tax54 \\ 430-52@g9.fc"
Saída: ["5493", "54", "430", "52", "9"]

Entrada: "sasprs] rasgou \" re \\ forz "
Saída: nulo, [], [""] ou similar

Por favor, coloque quantos bytes usados ​​por suas respostas e, como sempre, golfe feliz!

Diretrizes para Lisp

Aqui está o que conta e o que não conta nos dialetos Lisp:

;;; Opção 1

(desafinar extract-strings (ab); Não conta
  (coisa) ;;; Tudo aqui conta
); Não conta

;;; opção 2

(extrair strings de extração (string & aux (início 0) (final 0)); Não conta
  (coisa) ;;; Tudo aqui conta
); Não conta.

APL, 13 caracteres

(ou 28/30 bytes, leia abaixo)

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

Vejo que você baniu o GolfScript da sua pergunta. Entendo sua opinião, mas espero que essa comunidade não bana o APL, porque é uma linguagem de programação verdadeiramente notável, com uma longa história, sem mencionar muita diversão em codificar. Talvez possa ter uma pontuação diferente, se as pessoas sinto que está competindo injustamente. Vou postar meus pensamentos sobre esse assunto no tópico que você vinculou.

Nesse mesmo token, sempre adicionei uma nota de rodapé às minhas postagens de APL, alegando que o APL poderia ser pontuado como 1 char = 1 byte. Minha afirmação se baseia no fato de que algumas implementações de APL (principalmente comerciais) ainda suportam sua própria codificação herdada de byte único, com os símbolos da APL mapeados para os valores superiores de 128 bytes. Mas talvez isso seja um exagero; nesse caso, convém marcar essa entrada como 28 bytes em UTF-16 ou 30 bytes em UTF-8.

Explicação

{        ⍳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

Exemplos

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

O formato de saída padrão para uma matriz de seqüências de caracteres não deixa claro quantas seqüências existem na matriz, nem quantos espaços em branco. Mas uma manipulação rápida para adicionar aspas deve deixar bem claro:

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

Python 47

Implementação

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

Demo

>>> 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'], []]

Algoritmo

Converta cada caractere que não seja dígito em espaço e depois divida a sequência resultante. Uma abordagem simples e clara.

E uma solução divertida com itertools (71 caracteres)

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

Versão online para teste

Como converter qualquer caractere que não seja um dígito para um int retorna 0 em Ruby (com to_i), a conversão de todos os caracteres em int e de volta em char é a maneira não-regular de verificar um dígito ...

bash, 26 (conteúdo da função: 22 + sobrecarga de atribuição de matriz 4)

Isso não vai superar a outra bashresposta , mas é interessante porque pode fazer você pensar duas vezes:

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

O uso é:

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

À primeira vista, //+([!0-9])/parece muito com uma substituição de regexp, mas não é. É uma expansão de parâmetro bash , que segue regras de correspondência de padrões , em vez de regras de expressão regular.

Retornar tipos de array bash verdadeiros a partir de funções bash é uma tarefa difícil, então eu escolhi retornar uma lista delimitada por espaço e depois converter para um array em uma atribuição de array fora da chamada de função. Portanto, no interesse da justiça, acho que a (` `)chamada de função ao redor deve ser incluída na minha pontuação.

Mathematica 32

StringCases[#,DigitCharacter..]&

Uso

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"}, 
 {}
}

O equivalente a usar expressões regulares é muito mais longo !:

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

Bash, 21 bytes 17/21 bytes (aprimorado pelo DigitalTrauma )

Construindo uma lista separada por espaços com tr

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

substitui qualquer dígito por um espaço

Uso

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

Editar

conforme apontado pelos comentários abaixo, o código pode ser reduzido para 17 bytes:

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

e como o resultado não está falando estritamente uma matriz Bash, o uso deve ser

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

e o extra (``)deve ser contado

Smalltalk (Smalltalk / X), 81

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

valor f: 'abc123def456' -> OrderedCollection ('123' '456')

valor f: 'aitew034snk582: 3c' -> OrderedCollection ('034' '582' '3')

f value: 'as5493tax54 \ 430-52@g9.fc' -> OrderedCollection ('5493' '54' '430' '52' '9')

f valor: 'sasprs] rasgou \ "re \ forz' -> OrderedCollection ()

sigh - O Smalltalk tem uma tendência a usar nomes de funções muito longos ...

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

A função aceita uma string e retorna uma lista de strings.

Exemplos:

> 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

Nota: $xé o nome do elemento da lista.

Perl, 53

Editar: em nenhuma correspondência, sub agora retorna a lista com uma string vazia (em vez da lista vazia) conforme necessário.

Também evita a divisão em caracteres de espaço único, pois desencadeia o comportamento de 'divisão em qualquer espaço em branco' , o que provavelmente viola as regras. Eu poderia usar o / /delimitador, que seria dividido em espaço único, mas paradoxalmente pareceria usar o padrão regexp. Eu poderia usar unpacko custo de alguns caracteres extras e assim me livrar da splitcontrovérsia, mas acho que, com o que termino, dividir um caractere literal (que não seja o espaço) é bom.

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

E não, o operador de transliteração do Perl não faz expressões regulares. Eu posso desenrolar o intervalo de 0 a 9 para 0123456789se esse for o problema.

C, 68 bytes (apenas o corpo da função)

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;
}

O primeiro argumento é a sequência de entrada, o segundo é a matriz de saída, que é uma matriz de sequências terminada em NULL. É necessário reservar memória suficiente aantes de chamar a função (no pior caso:sizeof(char*)*((strlen(s)+1)/2) .

A sequência de entrada é modificada pela função (todo caractere que não seja dígito é substituído por '\0' )

Exemplo de uso

#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;
}

Resultado

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

Versão sem golfe:

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 sem declaração de função)

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

Embora não seja nada competitivo, estou surpreso que o VBScript seja tão curto quanto ao fato de ser detalhado (13 bytes apenas para os CRs). Ele percorre a cadeia de caracteres, substituindo caracteres não numéricos por espaços, reduz todo o espaço em branco a espaços únicos e, em seguida, usa um delimitador de espaço para dividi-lo.

Casos de teste

Input: "ab5c0x"
Output: 5,0

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

Lisp comum (1 de acordo com a letra; 3173 de acordo com o espírito)

Aqui está uma versão legível. A contagem de bytes é bastante alta devido aos nomes longos em coisas comodigit-char-p e position-ife 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")
#()

O conceito de "declaração de função" é meio vago. Aqui está uma versão que possui apenas um byte (o caractere xno corpo da função); tudo o mais é agrupado nas variáveis ​​auxiliares da lista de lamba da função (parte da declaração da função):

(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)

A contagem real de bytes dependerá de quantas declarações auxiliares precisarão ser movidas para o corpo para que isso seja considerado aceitável. Alguma renomeação de função local também ajudaria (por exemplo, diminua, position-ifpois aparece duas vezes, use variáveis ​​de letra única etc.).

Esta renderização do programa possui 220 caracteres:

(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))

Se nada mais, isso deve promover variáveis ​​auxiliares e comuns do Lisp .

Isso pode ser escrito de forma mais concisa loop, é claro:

(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)))

O loopformulário, com espaço extra removido, possui 173 caracteres:

(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 bytes

E para aqueles que estão curiosos, aqui está o meu provavelmente enorme golfe:

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

Acima em estampa bonita:

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;
}

Acima no código descritivo normal

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("]");}

Como C não possui funções de impressão em matriz incorporadas, eu tive que fazer esse trabalho sozinho, então peço desculpas por haver uma vírgula final em cada saída. Essencialmente, o que esse código faz é ler a sequência de caracteres, se não for um dígito, substitui-a por '\ 0' e, em seguida, apenas percorro o código e imprimo todas as cadeias de dígitos. (EOF = 0)

Entrada: ab5c0x
Saída: ["5", "0",]

Entrada: z526ks4f.; 8] \ p
Saída: ["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);
}

Primeiro, isso usa o .Select()método de extensão LINQ para transformar todos os não dígitos em vírgulas. string.Replace()seria preferível, pois retorna um em stringvez de um IEnumerable<char>, mas string.Replace()pode usar apenas um único caractere ou string e não pode usar um predicado comochar.IsDigit() or 47<c&c<58.

Como mencionado, .Select()aplicado a uma string retorna um IEnumerable<char>, então precisamos transformá-la novamente em uma string, transformando-a em uma matriz e passando a matriz para ostring construtor.

Finalmente, dividimos a string em vírgulas usando string.Split().(StringSplitOptions)1é uma maneira mais curta de dizer StringSplitOptions.RemoveEmptyEntries, que cuida automaticamente de várias vírgulas e vírgulas consecutivas no início / fim da sequência.

JS / Nó: 168 162 147 138 caracteres

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;
}

Versão embelezada:

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}

Define dígitos usando espaço negativo dentro do intervalo ascii imprimível.

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;}

Código descritivo:

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;
}

Este é um código bastante longo e tenho certeza de que haverá uma versão php muito mais curta para esse código de golfe. Isso é o que eu poderia criar no php.

Pitão

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]

Resposta @Abhijit é muito inteligente, esta é apenas uma versão "minificada" do que eu tinha em mente.

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") == []

Como não gera saída, o código está funcionando, se executado um a um, pois algumas variáveis ​​são definidas na declaração.

PHP 98 89

Como na resposta bash do DigitalTrauma, isso não usa um regex.

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;
}

Casos de teste:

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

Haskell 31

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

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

Divide a cadeia em todos os caracteres não numéricos e remove as cadeias vazias geradas por delimitadores consecutivos.

VBA 210, 181 sem declaração de função

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 caracteres)

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

Ungolfed e wrapped na declaração de função:

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

Exemplo de código no console 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

Golfe:

Edit: Quando os loops saem do final da matriz, céundefined , o que é falso e finaliza o loop.

27/2: Usar ?:salva o wordiness de 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
}

O retorno de carro no corpo é para facilitar a leitura e não faz parte da solução.

Ungolfed:

A idéia é anexar cada caractere à última entrada da matriz, se for um dígito, e garantir que a última entrada da matriz seja uma sequência.

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
}

Ungolfed

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

Entrada / saída de amostra

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

Esta função divide seqüências de caracteres por classe de caractere (isto não é regex! :)) classe é N - caracteres numéricos e P {N} significa negação dessa classe. o = T significa omitir substrings vazios.

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"));

Resultado

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

88 caracteres quando não está contando a função n (x) {}

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
}