이 문제는 제품 식별자를 나타내는 문자열을 세 가지 구성 요소로 분리하는 것입니다.

• 첫 번째 부분은 창고를 나타내는 임의의 길이의 대문자와 소문자로 구성됩니다.
• 두 번째 부분은 제품 번호를 나타내는 숫자입니다. 이 부분은 또한 임의의 길이입니다.
• 마지막 부분은 크기와 색상의 한정자이며이 부분은 문자열의 끝까지 계속됩니다. 규정자는 대문자로 시작하고 영숫자로 구성됩니다.

각 부분은 명확하게 분리되어 인쇄되어야합니다. 각 부분이 비어 있지 않은 것이 보장됩니다.

승자는이 문제를 해결하기 위해 최소 바이트를 사용하는 사람입니다.

: 예
입력 : UK7898S14의

출력 :
UK
7898
S14

영국은 영국, 7898은 제품 코드, S14는 14입니다.

예 2 :
입력 : cphDK1234CYELLOWS14QGOOD

출력 :
cphDK
1234
CYELLOWS14QGOOD

여기서 cphDK는 덴마크 코펜하겐이며 1234는 제품 코드이며 CYELLOWS14QGOOD는 노랑, 크기 14, 우수한 품질을 나타냅니다.

펄, 12 바이트

코드의 11 바이트 + -p플래그의 경우 1 바이트

s/\d+/
$&
/

그것을 실행하려면 :

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

APL, 18

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

문자에서 숫자로 또는 그 반대로 변경되는 처음 두 지점을 검색하고 그 지점을 사용하여 문자열을 분할하여 작동합니다.

망막 , 28 14 10 8 바이트

Dom Hastings 덕분에 4 바이트를 절약했습니다 . Martin Ender
덕분에 2 바이트를 절약했습니다 .

S1`(\d+)

온라인으로 사용해보십시오!

Haskell, 36 바이트 (정규식 없음)

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

결과는 형식으로 제공됩니다 ("UK",("7898","S14")). 아이디어는 첫 번째 자리에서 나누고 나머지는 첫 번째 자리가 아닌 자리에서 나누는 것입니다. Ideone에서 사용해보십시오 .

자바 스크립트, 38 36 바이트

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

예

const f =

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

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

자바 스크립트 (ES6), 28 26 바이트

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

@Grax 덕분에 2 바이트 절약

예

let f =

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

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

Gema, 17 12 자

( Dada 의 Perl 솔루션 에서 명백히 빌려온 국가 코드를 처리하지 않는 트릭 . 감사를 표해야합니다.)

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

샘플 실행 :

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

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

파이썬 2, 40 바이트

나는 많은 정규 표현식을 모르지만 고맙게도이 문제는 충분히 간단합니다. :) 입력 문자열을 각 부분을 포함하는 길이 3의 목록으로 분리합니다.

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

05AB1E ,39 37 16 바이트

Emigna 덕분에 많은 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

(이것은 나의 첫 번째 게시물입니다!)

자바 스크립트 (ES6), 36 바이트

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

예

let f =

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

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

자바 7, 200 185 174 167 바이트

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

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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

산출:

UK 7898 S14 
cphDK 1234 CYELLOWS14QGOOD 

씨#, 191177 바이트

골프 :

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

언 골프 드 :

    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는 14 바이트를 절약했습니다.

PHP, 48 바이트

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

그와 함께 $limit매개 변수, 그리고 환상적으로 유용 \K, preg_split()이 도전에 적합합니다.

MATLAB, 81 73 바이트

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

문자열을 받아서 세 문자열로 구성된 셀형 배열을 반환하는 함수입니다. 버전 R20105b에서 테스트되었습니다.

사용 예 :

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

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

설명

정규식 (?<=^\D+)\d+')은 문자열의 시작 부분에서 숫자가 아닌 숫자가 앞에 오는 숫자 그룹과 일치합니다. 후자는 경기의 일부가 아닙니다.

네 번째 출력 regexp은 IS 'match'; 그리고 일곱 번째 출력은 'split', 즉 일치 전후 문자열의 두 부분입니다.

루비, 28 바이트

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

이것은 줄 바꿈으로 첫 번째 숫자 클러스터를 둘러 쌉니다.

jq, 47 자

(43 자 코드 + 4 자 명령 행 옵션)

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

(오래된 이야기를 다시 시작하십시오. 처음에는 상당히 우아하고 고통스럽게 장황하게됩니다.)

샘플 실행 :

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

온라인 테스트 ( -rURL을 통한 전달 은 지원되지 않습니다 – 직접 출력 확인)

PHP, 61 59 56 55 바이트

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

초기 코드도 출력합니다.

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

편집하다

저에게 몇 바이트를 절약 해 준 @manatwork 덕분에 저에게 몇 바이트 더 저축 된
@ RomanGräf 덕분에

정규식이없는 JavaScript, 84 81 79 바이트

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

Mathematica, 39 바이트

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

익명의 기능. 문자열을 입력으로 취하고 문자열 목록을 출력으로 리턴합니다.

라켓 274 바이트

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

언 골프 드 :

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

테스트 :

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

산출:

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

R, 63 52 바이트

편집 : @ JDL 덕분에 많은 바이트를 절약했습니다.

stdin에서 입력을 받아서 stdout으로 인쇄합니다.

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

출력 예 :

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

젤리 , 14 바이트

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

TryItOnline!

어떻게?

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 바이트

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

전화 :

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

파이썬 2, 103 94 88 바이트

정규식을 사용하지 않는 솔루션

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

중간에서 숫자를 추출한 다음 숫자를 색인으로 사용하여 입력을 슬라이스합니다. 입력 주위에 따옴표가 필요하지만 따옴표가 허용되지 않는 곳을 보지 못했습니다.

-9를 중간 숫자로 나누고 중간에 b를 사용하여 구성 요소를 인쇄하여 -9

-6 @Shebang에게 감사합니다

테스트 사례

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

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

C #, 74 바이트

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

Johan Karlsson이 JavaScript에서 수행 한 것처럼 첫 번째 숫자 세트를 캐리지 리턴, 숫자 세트 및 다른 캐리지 리턴으로 바꿉니다.