Bu sorun, bir ürün tanımlayıcısını temsil eden bir dizeyi üç bileşene ayırmakla ilgilidir.

• İlk bölüm, depoyu temsil eden keyfi uzunluktaki üst ve alt harflerden oluşur.
• İkinci kısım ürün numarasını temsil eden rakamlardır. Bu kısım da keyfi uzunluktadır.
• Son bölüm boyut ve renkler olarak niteleyicilerdir ve bu bölüm dizenin sonuna kadar devam eder. Niteleyicilerin büyük harfle başlaması ve alfasayısal karakterlerden oluşması garanti edilir.

Her parça açıkça ayrılmış olarak yazdırılmalıdır. Her parçanın boş olmadığı garanti edilir.

Kazanan, bu sorunu çözmek için en az bayt kullanan kişidir.

: Örnek
Girişi: UK7898S14

Çıkış:
UK
7898
S14

İşte İngiltere İngiltere, 7898 ürün kodu ve S14 boyut 14.

Örnek 2:
Giriş: cphDK1234CYELLOWS14QGOOD

Çıktı:
cphDK
1234
CYELLOWS14QGOOD

Burada cphDK Kopenhag, Danimarka, 1234 ürün kodudur, CYELLOWS14QGOOD sarı rengi, 14 numarayı ve kaliteyi temsil eder.

Perl, 12 bayt

11 bayt kod + -pbayrak için 1 bayt .

s/\d+/
$&
/

Çalıştırmak için:

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

APL, 18

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

Karakterden basamağa veya tam tersine bir değişiklik olduğu ilk 2 noktayı arayarak ve dizeyi bölmek için bunları kullanarak çalışır.

Retina , 28 14 10 8 bayt

Dom Hastings sayesinde 4 bayt tasarruf etti . Martin Ender
sayesinde 2 bayt tasarruf etti .

S1`(\d+)

Çevrimiçi deneyin!

Haskell, 36 bayt (normal ifade yok)

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

Bu, sonucu formatta verir ("UK",("7898","S14")). Fikir, ilk basamakta bölmek ve daha sonra geri kalan kısmı ilk basamak olmayan kısımda bölmektir. Ideone üzerinde deneyin .

JavaScript, 38 36 bayt

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

Misal

const f =

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

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

JavaScript (ES6), 28 26 bayt

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

@Grax sayesinde 2 bayt kaydedildi

Örnekler

let f =

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

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

Gema, 17 12 karakter

(Açık bir şekilde shamelessly ödünç ülke kodunu işleme değil hile dada sitesindeki Perl çözeltisi . Takdir orada ifade edilmelidir.)

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

Örnek çalışma:

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 Bayt

Çok fazla Regex bilmiyorum, ama neyse ki bu sorun yeterince basit :) Giriş dizesini her parçayı içeren uzunluk 3 listesine ayırır.

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

05AB1E ,39 37 16 bayt

Emigna sayesinde çok bayt tasarruf etti.

CP-1252 kodlaması kullanır.

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

Çevrimiçi deneyin!

(Bu benim ilk yazım!)

JavaScript (ES6), 36 bytes

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

Examples

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 & test code:

Try it here.

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

Output:

UK 7898 S14 
cphDK 1234 CYELLOWS14QGOOD 

C#, 191 177 bytes

Golfed:

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 saved 14 bytes.

PHP, 48 bytes

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

With its $limit parameter, and the fantastically useful \K, preg_split() is perfect for this challenge.

MATLAB, 81 73 bytes

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

Function that accepts a string and returns a cell array of three strings. Tested in version R20105b.

Example use:

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

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

Explanation

The regular expression (?<=^\D+)\d+') matches a group of digits preceded by non-digits from the start of the string; the latter are not part of the match.

The fourth output of regexp is the 'match'; and the seventh output is the 'split', that is, the two parts of the string before and after the match.

Ruby, 28 bytes

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

This surrounds the first cluster of digits with newlines.

jq, 47 characters

(43 characters code + 4 characters command line options.)

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

(Again the old story: fairly elegant at the beginning, then becomes painfully verbose.)

Sample run:

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

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

PHP, 61 59 5655 bytes

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

This does output the initial code as well:

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

Edit

Thanks to @manatwork for saving a few bytes for me
Thanks to @RomanGräf for another few bytes saved

JavaScript without 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]&

Anonymous function. Takes a string as input, and returns a list of strings as output.

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

Testing:

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

Output:

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

R, 63 52 bytes

Edit: Saved a bunch of bytes thanks to @JDL

Takes input from stdin and prints to stdout:

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

Example output:

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

Jelly, 14 bytes

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

TryItOnline!

How?

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

Call with:

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

Python 2, 103 94 88 bytes

Solution without using 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

Simply extracts the numbers from the middle then slices the input using the number as an index. Requires quotes around the input but I didn't see anywhere that quotes are disallowed.

-9 by splitting a on the middle number then print the components with b in the middle

-6 Thanks to @Shebang

Test Cases

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

Replace 1st set of digits with carriage return, set of digits, and another carriage return, as Johan Karlsson did for JavaScript.