Este problema se trata de separar una cadena que representa un identificador de producto en tres componentes.

• La primera parte consta de letras superiores e inferiores de longitud arbitraria que representa el almacén.
• La segunda parte son los dígitos que representan el número del producto. Esta parte también es de longitud arbitraria.
• La última parte son calificadores como tamaño y colores, y esta parte continúa hasta el final de la cadena. Los calificadores están garantizados para comenzar con una letra mayúscula y consisten en caracteres alfanuméricos.

Cada parte debe imprimirse claramente separada. Se garantiza que cada parte no está vacía.

El ganador es el que usa menos bytes para resolver este problema.

Ejemplo:
Entrada: UK7898S14

Salida:
Reino Unido
7898
S14

Aquí Reino Unido es Reino Unido, 7898 es el código del producto y S14 es talla 14.

Ejemplo 2:
Entrada: cphDK1234CYELLOWS14QGOOD

Salida:
cphDK
1234
CYELLOWS14QGOOD

Aquí cphDK es Copenhague, Dinamarca, 1234 es el código del producto, CYELLOWS14QGOOD representa color amarillo, tamaño 14 y buena calidad.

Perl, 12 bytes

11 bytes de código + 1 byte para -pbandera.

s/\d+/
$&
/

Para ejecutarlo:

perl -pe 's/\d+/
$&
/' <<< "CYELLOWS14QGOOD"

APL, 18

{⍵⊂⍨3⌊+\1,2≠/⍵∊⎕D}'UK7898S14'
UK  7898  S14 

Funciona buscando los primeros 2 puntos donde hay un cambio de carácter a dígito o viceversa, y usándolos para dividir la cadena.

Retina , 28 14 10 8 bytes

Guardado 4 bytes gracias a Dom Hastings .
Guardado 2 bytes gracias a Martin Ender .

S1`(\d+)

Pruébalo en línea!

Haskell, 36 bytes (sin expresiones regulares)

d c='/'<c&&c<':'
(span d<$>).break d

Esto da el resultado en el formato ("UK",("7898","S14")). La idea es dividir en el primer dígito, y luego dividir el resto en el primer no dígito. Pruébalo en Ideone .

JavaScript, 38 36 bytes

s=>/(\D+)(\d+)(.+)/.exec(s).slice(1)

Ejemplo

const f =

s=>/(\D+)(\d+)(.+)/.exec(s).slice(1)

console.log(f("UK7898S14"));
console.log(f("cphDK1234CYELLOWS14QGOOD"));

JavaScript (ES6), 28 26 bytes

s=>s.replace(/\d+/,`
$&
`)

Guardado 2 bytes gracias a @Grax

Ejemplos

let f =

s=>s.replace(/\d+/,`
$&
`)

console.log(f('UK7898S14'));
console.log(f('cphDK1234CYELLOWS14QGOOD'));

Gema, 17 12 caracteres

(El truco de no manejar el código de país se tomó prestado descaradamente de la solución Perl de Dada . El agradecimiento debe expresarse allí).

<D>*=\n$1\n*

Ejecución de muestra:

bash-4.3$ gema '<D>*=\n$1\n*' <<< 'UK7898S14'
UK
7898
S14

bash-4.3$ gema '<D>*=\n$1\n*' <<< 'cphDK1234CYELLOWS14QGOOD'
cphDK
1234
CYELLOWS14QGOOD

Python 2, 40 bytes

No sé mucho Regex, pero afortunadamente este problema es bastante simple :) Separa la cadena de entrada en una lista de longitud 3 que contiene cada parte.

import re
lambda k:re.split('(\d+)',k,1)

05AB1E ,39 37 16 bytes

Ahorré muchos bytes gracias a Emigna.

Utiliza la codificación CP-1252.

TvDSdykF¬?¦}¶?}?

T                push "10"
 v               for each element (i.e., 1 and 0). Element is stored in 'y'
  DS             split string (input during the first iteration)
    d            for each character, 1 if digit or 0 otherwise
     yk          get index of the first occurrence of 'y'
       F         for 0 <= i < string.firstIndexOf(y)
        ¬?       print the first character of the string
          ¦      remove it from the string
           }     end inner for
            ¶?   display a newline
              }  end outer for
               ? display the remaining string

Pruébalo en línea!

(¡Esta es mi primera publicación acá!)

JavaScript (ES6), 36 bytes

s=>/(.+?)(\d+)(.*)/.exec(s).slice(1)

Ejemplos

let f =

s=>/(.+?)(\d+)(.*)/.exec(s).slice(1)

console.log(f('UK7898S14'));
console.log(f('cphDK1234CYELLOWS14QGOOD'));

Java 7, 200 185 174 167 bytes

import java.util.regex.*;String c(String s){Matcher m=Pattern.compile("(.*?)(\\d+)(.*)").matcher(s);s="";for(int i=0;i<3;)if(m.matches())s+=m.group(++i)+" ";return s;}

Ungolfed y código de prueba:

Pruébalo aquí

import java.util.regex.*;
class M{
  static String c(String s){
    Matcher m = Pattern.compile("(.*?)(\\d+)(.*)").matcher(s);
    s = "";
    for(int i = 0; i < 3;){
      if(m.matches()){
        s += m.group(++i) + " ";
      }
    }
    return s;
  }

  public static void main(String[] a){
    System.out.println(c("UK7898S14"));
    System.out.println(c("cphDK1234CYELLOWS14QGOOD"));
  }
}

Salida:

UK 7898 S14 
cphDK 1234 CYELLOWS14QGOOD 

C #, 191 177 bytes

Golfizado:

void F(string s){var a=s.ToList();int i=a.FindIndex(char.IsDigit);int n=a.FindIndex(i,char.IsUpper);Console.Write($"{s.Substring(0,i)}\n{s.Substring(i,n-i)}\n{s.Substring(n)}");

Sin golf:

    void F(string s)
    {
        var a = s.ToList();
        int i = a.FindIndex(char.IsDigit);
        int n = a.FindIndex(i, char.IsUpper);

        Console.Write($"{s.Substring(0, i)}\n{s.Substring(i, n - i)}\n{s.Substring(n)}");
    }

EDITAR1: @Link Ng guardó 14 bytes.

PHP, 48 bytes

print_r(preg_split('/(\D+|\d+)\K/',$argv[1],3));

Con su $limitparámetro y la fantásticamente útil \K, preg_split()es perfecto para este desafío.

MATLAB, 81 73 bytes

function y=f(x)
[~,~,~,m,~,~,s]=regexp(x,'(?<=^\D+)\d+');y=[s(1) m s(2)];

Función que acepta una cadena y devuelve una matriz de celdas de tres cadenas. Probado en la versión R20105b.

Ejemplo de uso:

>> f('UK7898S14')
ans = 
    'UK'    '7898'    'S14'

>> f('cphDK1234CYELLOWS14QGOOD')
ans = 
    'cphDK'    '1234'    'CYELLOWS14QGOOD'

Explicación

La expresión regular (?<=^\D+)\d+') coincide con un grupo de dígitos precedidos por no dígitos desde el comienzo de la cadena; estos últimos no son parte del partido.

La cuarta salida de regexpes el 'match'; y la séptima salida son las 'split'dos partes de la cadena antes y después del partido.

Rubí, 28 bytes.

->s{puts s.sub(/\d+/,"\n\\&\n")}

Esto rodea el primer grupo de dígitos con nuevas líneas.

jq, 47 caracteres

(Código de 43 caracteres + opciones de línea de comando de 4 caracteres).

match("(\\D+)(\\d+)(.+)").captures[].string

(Nuevamente, la vieja historia: bastante elegante al principio, luego se vuelve dolorosamente detallada).

Ejecución de muestra:

bash-4.3$ jq -Rr 'match("(\\D+)(\\d+)(.+)").captures[].string' <<< 'UK7898S14'
UK
7898
S14

bash-4.3$ jq -Rr 'match("(\\D+)(\\d+)(.+)").captures[].string' <<< 'cphDK1234CYELLOWS14QGOOD'
cphDK
1234
CYELLOWS14QGOOD

Prueba en línea ( -rno se admite el paso por la URL; compruebe usted mismo la salida sin formato).

PHP, 61 59 56 55 bytes

preg_match('/(\D+)(\d+)(.+)/',$argv[1],$a);print_r($a);

Esto también genera el código inicial:

Array
(
    [0] => cphDK1234CYELLOWS14QGOOD
    [1] => cphDK
    [2] => 1234
    [3] => CYELLOWS14QGOOD
)

Editar

Gracias a @manatwork por guardar algunos bytes para mí
Gracias a @ RomanGräf por otros pocos bytes guardados

JavaScript sin expresión regular, 84 81 79 bytes

p=>{for(i=n=o='';i<p.length;){if(n==isNaN(c=p[i++])){o+=' ';n++}o+=c}return o}

Mathematica, 39 bytes

StringSplit[#,a:DigitCharacter..:>a,2]&

Función anónima. Toma una cadena como entrada y devuelve una lista de cadenas como salida.

Raqueta 274 bytes

(let((g 0)(j'())(k'())(l'())(m list->string)(r reverse)(n char-numeric?)(c cons))(for((i(string->list s)))
(when(and(= g 0)(n i))(set! g 1))(when(and(= g 1)(not(n i)))(set! g 2))(match g[0(set! j(c i j))]
[1(set! k(c i k))][2(set! l(c i l))]))(list(m(r j))(m(r k))(m(r l))))

Sin golf:

(define (f s)
  (let ((g 0)
        (j '())
        (k '())
        (l '())
        (m list->string)
        (r reverse)
        (n char-numeric?)
        (c cons))
    (for ((i (string->list s)))
      (when (and (= g 0) (n i)) (set! g 1)  )
      (when (and (= g 1) (not (n i))) (set! g 2) )
      (match g
        [0 (set! j (c i j))]
        [1 (set! k (c i k))]
        [2 (set! l (c i l))]))
    (list (m (r j)) (m (r k)) (m (r l)))))

Pruebas:

(f "UK7898S14")
(f "cphDK1234CYELLOWS14QGOOD")

Salida:

'("UK" "7898" "S14")
'("cphDK" "1234" "CYELLOWS14QGOOD")

R, 63 52 bytes

Editar: guardado un montón de bytes gracias a @JDL

Toma datos de stdin e imprime en stdout:

gsub("([a-z]+)(\\d+)(.+)","\\1 \\2 \\3",scan(,""),T)

Salida de ejemplo:

[1] "UK 7898 S1"
[1] "cphDK 1234 CYELLOWS14QGOOD"

Jalea , 14 bytes

O<65ITḣ2‘ṬœṗµY

TryItOnline!

¿Cómo?

O<65ITḣ2‘ṬœṗµY - Main link: productIdentifier   e.g. "UK7898S14"
O              - cast to ordinals               e.g. [85,75,55,56,57,56,83,49,52]
 <65           - less than 65?                  e.g. [ 0, 0, 1, 1, 1, 1, 0, 1, 1]
    I          - incremental difference         e.g. [ 0, 1, 0, 0, 0,-1, 1, 0]
     T         - truthy indexes                 e.g. [2, 6, 7]
      ḣ2       - head to 2                      e.g. [2, 6]
        ‘      - increment                      e.g. [3, 7]
         Ṭ     - set truthy indexes             e.g. [0, 0, 1, 0, 0, 0, 1]
          œṗ   - split y at truthy indexes of x e.g. ["UK", "7898", "S14"]
            µ  - monadic chain separation
             Y - join with line feeds

C, 107 bytes

#define p(x) printf("%c",x);
f(char*s){for(;*s>64;s++)p(*s)p(10)for(;*s<58;s++)p(*s)p(10)for(;*s;s++)p(*s)}

Llamar con:

int main()
{
   f("UK7898S14");
   return 0;
}

Python 2, 103 94 88 bytes

Solución sin usar regex

a,b=input(),""
for f in a:
 if ord(f)<58:b+=f
 elif b"":c,d=a.split(b);print c,b,d;break

Simplemente extrae los números del medio y luego corta la entrada usando el número como índice. Requiere comillas alrededor de la entrada, pero no vi en ninguna parte que las comillas no estén permitidas.

-9 dividiendo a en el número del medio y luego imprima los componentes con b en el medio

-6 Gracias a @Shebang

Casos de prueba

D:\>python codes.py
"UK7898S14"
UK 7898 S14

D:\>python codes.py
"cphDK1234CYELLOWS14QGOOD"
cphDK 1234 CYELLOWS14QGOOD

C #, 74 bytes

v=>new System.Text.RegularExpressions.Regex("\\d+").Replace(v,"\n$&\n",1);

Reemplace el primer conjunto de dígitos con retorno de carro, conjunto de dígitos y otro retorno de carro, como hizo Johan Karlsson para JavaScript.