In diesem Problem wird eine Zeichenfolge, die eine Produktkennung darstellt, in drei Komponenten unterteilt.

• Der erste Teil besteht aus beliebig langen oberen und unteren Buchstaben, die das Lager darstellen.
• Der zweite Teil besteht aus Ziffern, die die Produktnummer darstellen. Dieser Teil ist ebenfalls von beliebiger Länge.
• Der letzte Teil ist Qualifizierer wie Größe und Farben, und dieser Teil fährt bis zum Ende der Zeichenkette fort. Die Qualifikationsmerkmale beginnen garantiert mit einem Großbuchstaben und bestehen aus alphanumerischen Zeichen.

Jeder Teil sollte klar getrennt gedruckt werden. Es ist garantiert, dass jedes Teil nicht leer ist.

Der Gewinner ist derjenige, der die wenigsten Bytes verwendet, um dieses Problem zu lösen.

Beispiel:
Eingabe: UK7898S14

Ausgabe:
UK
7898
S14

Hier ist Großbritannien, 7898 ist der Produktcode und S14 ist Größe 14.

Beispiel 2:
Eingabe: cphDK1234CYELLOWS14QGOOD

Ausgabe:
cphDK
1234
CYELLOWS14QGOOD

Hier ist cphDK Kopenhagen, Dänemark, 1234 ist der Produktcode, CYELLOWS14QGOOD steht für gelbe Farbe, Größe 14 und gute Qualität.

Perl, 12 Bytes

11 Byte Code + 1 Byte für -pFlag.

s/\d+/
$&
/

Um es auszuführen:

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

APL, 18

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

Durchsucht die ersten beiden Punkte, an denen ein Wechsel von Zeichen zu Ziffer oder umgekehrt stattfindet, und teilt die Zeichenfolge mit diesen Punkten.

Retina , 28 14 10 8 Bytes

4 Bytes gespart dank Dom Hastings .
2 Bytes gespart dank Martin Ender .

S1`(\d+)

Probieren Sie es online!

Haskell, 36 Bytes (kein regulärer Ausdruck)

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

Dies gibt das Ergebnis im Format ("UK",("7898","S14")). Die Idee ist, bei der ersten Ziffer zu teilen und dann den Rest bei der ersten Nicht-Ziffer zu teilen. Probieren Sie es auf Ideone .

JavaScript, 38 36 Bytes

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

Beispiel

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+/,`
$&
`)

2 Bytes dank @Grax gespart

Beispiele

let f =

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

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

Gema, 17 12 Zeichen

(Der Trick , den Ländercode nicht explizit Umgang schamlos ausgeliehen von Dada ‚s Perl - Lösung . Appreciation sollte zum Ausdruck gebracht werden.)

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

Probelauf:

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

Ich kenne nicht viel Regex, aber zum Glück ist dieses Problem einfach genug :) Trennt die Eingabezeichenfolge in eine Liste der Länge 3, die jeden Teil enthält.

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

05AB1E ,39 37 16 Bytes

Dank Emigna wurden viele Bytes gespart.

Es wird die CP-1252-Codierung verwendet.

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

Probieren Sie es online!

(Dies ist mein erster Beitrag hier!)

JavaScript (ES6), 36 Byte

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

Beispiele

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 & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

UK 7898 S14 
cphDK 1234 CYELLOWS14QGOOD 

C #, 191 177 Bytes

Golf gespielt:

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

Ungolfed:

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

EDIT1: @Link Ng sparte 14 Bytes.

PHP, 48 Bytes

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

Mit seinen $limitParametern und die phantastisch nützlich \K, preg_split()ist für diese Herausforderung perfekt.

MATLAB, 81 73 Bytes

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

Funktion, die eine Zeichenfolge akzeptiert und ein Zellenarray mit drei Zeichenfolgen zurückgibt. Getestet in Version R20105b.

Beispiel Verwendung:

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

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

Erläuterung

Der reguläre Ausdruck (?<=^\D+)\d+')entspricht einer Gruppe von Ziffern, denen vom Anfang der Zeichenfolge an keine Ziffern vorangestellt sind. Letztere sind nicht Teil des Spiels.

Die vierte Ausgabe von regexpist die 'match'; und die siebte Ausgabe ist die 'split', dh die zwei Teile der Zeichenkette vor und nach dem Match.

Ruby, 28 Bytes

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

Dies umgibt den ersten Ziffernblock mit Zeilenumbrüchen.

47 Zeichen

(43 Zeichen Code + 4 Zeichen Befehlszeilenoptionen.)

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

(Wieder die alte Geschichte: am Anfang ziemlich elegant, dann wird sie schmerzhaft wortreich.)

Probelauf:

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

Online-Test (Die Weitergabe -rüber eine URL wird nicht unterstützt. Prüfen Sie die Raw-Ausgabe selbst.)

PHP, 61 59 56 55 Bytes

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

Dies gibt auch den Anfangscode aus:

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

Bearbeiten

Vielen Dank an @manatwork für die Speicherung einiger Bytes.
Vielen Dank an @ RomanGräf für die Speicherung einiger weiterer Bytes

JavaScript ohne Regex, 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]&

Anonyme Funktion. Nimmt eine Zeichenfolge als Eingabe und gibt eine Liste von Zeichenfolgen als Ausgabe zurück.

Schläger 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))))

Ungolfed:

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

Testen:

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

Ausgabe:

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

R, 63 52 Bytes

Bearbeiten: Speichert dank @JDL eine Menge Bytes

Übernimmt die Eingabe von stdin und druckt nach stdout:

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

Beispielausgabe:

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

Jelly , 14 Bytes

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

TryItOnline!

Wie?

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

Rufen Sie an mit:

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

Python 2, 103 94 88 Bytes

Lösung ohne Verwendung von 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

Extrahiert einfach die Zahlen aus der Mitte und schneidet die Eingabe mit der Zahl als Index. Erfordert Anführungszeichen um die Eingabe, aber ich habe nirgends festgestellt, dass Anführungszeichen nicht zulässig sind.

-9 durch Teilen von a auf die mittlere Zahl und Drucken der Komponenten mit b in der Mitte

-6 Danke an @Shebang

Testfälle

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

Ersetzen Sie die erste Ziffernfolge durch Wagenrücklauf, Ziffernfolge und eine weitere Wagenrücklauffolge, wie es Johan Karlsson für JavaScript getan hat.