17

यह समस्या किसी उत्पाद पहचानकर्ता को तीन घटकों में दर्शाने वाली स्ट्रिंग को अलग करने के बारे में है।

पहले भाग में मनमानी लंबाई के ऊपरी और निचले अक्षर होते हैं जो गोदाम का प्रतिनिधित्व करते हैं।
दूसरा भाग अंक है जो उत्पाद संख्या का प्रतिनिधित्व करता है। यह हिस्सा भी मनमानी लंबाई का है।
अंतिम भाग आकार और रंगों के रूप में क्वालीफायर है, और यह भाग स्ट्रिंग के अंत तक जारी रहता है। क्वालिफायर को एक कैपिटल लेटर के साथ शुरू करने और अल्फ़ान्यूमेरिक वर्णों से मिलकर बनाए जाने की गारंटी है।

प्रत्येक भाग को स्पष्ट रूप से अलग-अलग मुद्रित किया जाना चाहिए। यह गारंटी दी जाती है कि प्रत्येक भाग गैर-रिक्त है।

विजेता वह है जो इस समस्या को हल करने के लिए कम से कम बाइट्स का उपयोग करता है।

उदाहरण:
इनपुट: UK7898S14

आउटपुट:
यूके
7898
S14

यहां यूके यूनाइटेड किंगडम है, 7898 उत्पाद कोड है, और S14 का आकार 14 है।

उदाहरण 2:
इनपुट: cphDK1234CYELLOWS14QGOOD

आउटपुट:
cphDK
1234
CYELLOWS14QGOOD

यहाँ cphDK कोपेनहेगन, डेनमार्क, 1234 उत्पाद कोड है, CYELLOWS14QGOOD पीले रंग, आकार 14 और अच्छी गुणवत्ता का प्रतिनिधित्व करता है।

code-golf string

— Highace2
स्रोत

2

क्या प्रत्येक भाग गैर-रिक्त है?

— कार्ल नैप

@KarlNapf हां। प्रत्येक भाग गैर-रिक्त है।

— हिघसे २

@Emigna एक अतिरिक्त उदाहरण अब शामिल किया गया है।

— हिघसे २

"पहले भाग में ऊपरी और निचले अक्षर होते हैं" - हो सकता है कि उदाहरणों में से एक में ऊपरी और निचले अक्षरों का मिश्रण हो। और शायद एक देश कोड भी है जो 2 वर्ण लंबा नहीं है। इसके अलावा, क्या क्वालिफायर में "गुणवत्ता ★★★ ☆ ☆" जैसे गैर-अल्फ़ान्यूमेरिक वर्ण शामिल हो सकते हैं?

— मैनटवर्क

PPCG में आपका स्वागत है!

— आउटगोल्फर

10

पर्ल, 12 बाइट्स

-pध्वज के लिए कोड + 1 बाइट के 11 बाइट्स ।

s/\d+/
$&
/

इसे चलाने के लिए:

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

— बापू
स्रोत

2

सादगी को प्यार करो! :)

— डोम हेस्टिंग्स

4

एपीएल, 18

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

पहले 2 बिंदुओं को खोजकर काम करता है जहां चरित्र से अंक या इसके विपरीत में परिवर्तन होता है, और स्ट्रिंग को विभाजित करने के लिए उन का उपयोग किया जाता है।

— मोरिस ज़ुक्का
स्रोत

4

रेटिना , 28 14 10 8 बाइट्स

डोम हेस्टिंग्स के लिए धन्यवाद 4 बाइट्स सहेजे गए । मार्टिन एंडर की बदौलत
2 बाइट्स बचाए ।

S1`(\d+)

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

@ दादा के जवाब के रूप में एक ही तंत्र का उपयोग करते हुए, आप एक और 4 बाइट बचा सकते हैं: retina.tryitonline.net/… (tbh, शायद और भी अधिक, लेकिन यह सब मैं बचा सकता है! :))

— डोम हेस्टिंग्स

@DomHastings। आह, अच्छा विचार की जगह के साथ जा रहा है!

— एमिगा

3

हास्केल, 36 बाइट्स (रेगेक्स नहीं)

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

यह प्रारूप में परिणाम देता है ("UK",("7898","S14"))। विचार को पहले अंक में विभाजित करना है, और फिर बाकी को पहले गैर-अंक में विभाजित करना है। Ideone पर इसे आज़माएं ।

— Zgarb
स्रोत

एक टुप पर fmap का अच्छा उपयोग।

— xnor

3

जावास्क्रिप्ट, 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"));

Expand snippet

— फ्लोरेंट
स्रोत

@ अरनुलद गुड कैच।

— फ्लोरेंट

3

जावास्क्रिप्ट (ईएस 6), 28 26 बाइट्स

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

2 बाइट्स @Grax की बदौलत सहेजे गए

उदाहरण

कोड स्निपेट दिखाएं

let f =

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

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

Expand snippet

— जोहान कार्लसन
स्रोत

आप अपनी जगह $ और का उपयोग करके और कोष्ठक को हटाकर 2 और वर्णों को कम कर सकते हैं। s=>s.replace(/\d+/,` $& `)

— ग्रैक्स 32

2

भीम, १ , १२ अक्षर

( दादा के पर्ल समाधान से स्पष्ट रूप से बेशर्मी से उधार लिया गया देश कोड नहीं संभालने की चाल । प्रशंसा वहाँ व्यक्त की जानी चाहिए।)

<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

पायथन 2, 40 बाइट्स

मैं बहुत रेगेक्स नहीं जानता, लेकिन शुक्र है कि यह समस्या काफी सरल है :) इनपुट स्ट्रिंग को लंबाई 3 की सूची में शामिल करता है जिसमें कुछ भाग होता है।

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

— Kade
स्रोत

2

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

इसे ऑनलाइन आज़माएं!

(यहाँ मेरा यह पहला पोस्ट है!)

— Osable
स्रोत

आप अक्षरों के बजाय अंकों की जांच करके कम से कम 14 बाइट्स बचा सकते हैं । और यह संभवतः अधिक गोल्फ हो सकता है।

— Emigna

इसके अलावा, PPCG में आपका स्वागत है :)

— Emigna

धन्यवाद! और आप सही हैं, वास्तव में मैं इस एक पर सभी भोले चला गया, सचमुच बाएं से दाएं। मैंने .páà¬पहला भाग प्राप्त करने के लिए खुदाई करने की भी कोशिश की , लेकिन यह पहली नज़र में बाकी लोगों की मदद नहीं करता है।

— 17

मेरे कोड के साथ अपने जवाब को अपडेट करने के लिए स्वतंत्र महसूस करें (और यदि आप कर सकते हैं तो इसे कुछ और गोल्फ करें)। मुझे नहीं लगता कि यह वारंट के लिए पर्याप्त है, इसका खुद का जवाब है।

— इविना

ठीक है, मैं इसे करूँगा, क्योंकि मुझे इसे लूप में रखने का एक तरीका मिला। कुछ भी परिष्कृत नहीं है, लेकिन कम से कम यह 16 बाइट्स तक जाता है। फिर से धन्यवाद! (अब मुझे स्पष्टीकरण अपडेट करना है ... लेकिन समझाने के लिए बहुत कम बाइट्स हैं)

— ओविएबल

1

जावास्क्रिप्ट (ईएस 6), 36 बाइट्स

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

उदाहरण

कोड स्निपेट दिखाएं

let f =

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

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

Expand snippet

— Arnauld
स्रोत

1

जावा 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;}

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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

— केविन क्रूज़सेन
स्रोत

1

सी #, 191 177 बाइट्स

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 ने 14 बाइट्स बचाए।

— paldir
स्रोत

आपको ToCharArray () की आवश्यकता नहीं है। स्ट्रिंग पहले से ही IEnumerable है <char>

— Link Ng

बेशक, मुझे विश्वास नहीं हो रहा है कि मैंने इस पर ध्यान नहीं दिया।

— पालदिर ir

1

PHP, 48 बाइट्स

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

अपने $limitपैरामीटर के साथ , और काल्पनिक रूप से उपयोगी \K, preg_split()इस चुनौती के लिए एकदम सही है।

— user59178
स्रोत

1

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है'match' ; और सातवाँ आउटपुट है 'split', यानी, मैच के पहले और बाद में स्ट्रिंग के दो हिस्से।

— लुइस मेंडो
स्रोत

1

रूबी, 28 बाइट्स

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

यह न्यूलाइन्स के साथ अंकों के पहले क्लस्टर को घेरता है।

— ली डब्ल्यू
स्रोत

0

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 से गुजरना समर्थित नहीं है - रॉ आउटपुट को स्वयं देखें)

— आदमी काम पर है
स्रोत

0

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 को धन्यवाद

— gabe3886
स्रोत

1

[\d]? : ओ \dकाफी है।

— मैनावर्क

@manatwork धन्यवाद। मैं रेगेक्स का उपयोग पर्याप्त रूप से नहीं करता (यकीनन एक अच्छी बात है) और नीचे शुरू किया [0-9] + मार्ग के बारे में याद करने से पहले \ d

— gabe3886

1

क्यों नहीं की जगह [a-z]के साथ \D?

— रोमन ग्रफ

1

अब जब आपके पास नहीं है [a-z], तो iध्वज की आवश्यकता नहीं है।

— मैनटवर्क

मुझे वास्तव में नियमित अभिव्यक्तियों पर काम करने के लिए अधिक समय देने की आवश्यकता है।

— gabe3886

0

जावास्क्रिप्ट रेगेक्स के बिना, 84 81 79 बाइट्स

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

— फ़िलिप फ़्लेनर
स्रोत

2

आप सभी इनिशियलाइज़ेशन को एक ही स्थान पर रख सकते हैं o=n=i='':।

— मैनावर्क

और असाइनमेंट को c से उसके पहले उपयोग में ले जाएँ isNaN(c=p[i++]):।

— मैनावर्क

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

— रोमन ग्रैफ

@ रोमनग्रफ, आरंभीकरण बना रहना चाहिए ''क्योंकि ओ, जिसके परिणाम को संक्षिप्त किया जाएगा। लेकिन दुख की बात है कि आपका कोड मेरे लिए काम नहीं कर रहा है, मुझे सशर्त रूप से वेतन वृद्धि की आवश्यकता है।

— पुरुषार्थ

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

— रोमन ग्रैफ

0

गणितज्ञ, 39 बाइट्स

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

अनाम फ़ंक्शन। एक स्ट्रिंग को इनपुट के रूप में लेता है, और आउटपुट के रूप में स्ट्रिंग की एक सूची देता है।

— LegionMammal978
स्रोत

0

रैकेट 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))))

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

परिक्षण:

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

आउटपुट:

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

— rnso
स्रोत

0

आर, 63 52 बाइट्स

संपादित करें: @JDL की बदौलत बाइट्स का एक गुच्छा सहेजा गया

स्टड और प्रिंट से इनपुट को स्टडआउट तक ले जाता है:

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

उदाहरण आउटपुट:

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

— Billywob
स्रोत

gsub (...,"\\1 \\2 \\3")अधिक कुशल नहीं होगा ?

— JDL

@JDL मुझे यकीन नहीं है। एक उदाहरण देने या बताने के लिए देखभाल?

— बिलीवॉब

कुछ ऐसा है gsub("([A-Za-z]+)([0-9]+)(.+)","\\1 \\2 \\3",scan()), हालांकि पहला तर्क शायद इससे कुछ छोटा है ...

— JDL

@JDL बहुत चालाक है लेकिन मुझे पता नहीं है कि "\\1 \\2 \\3"प्रतिस्थापन कैसे काम करता है। रेगेक्स पैटर्न को भी थोड़ा अपडेट किया और उपयोग किया ignore.case = TRUE।

— बिलीवॉब

उन्हें बस "आउटपुट का मतलब है जो पहले / दूसरे / तीसरे जोड़ी के ()कोष्ठक में कैप्चर किया गया था ।

— JDL

0

जेली , 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

— जोनाथन एलन
स्रोत

0

सी, 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;
}

— Steadybox
स्रोत

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 से प्रिंट करें

-6 @Shebang को धन्यवाद

परीक्षण के मामलों

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

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

— ElPedro
स्रोत

b!="" -> b>""और c=a.split(b) -> c,d=a.split(b) ... print c[0],b,c[1] -> print c,b,d5 बाइट्स बचाता है।

— केड

बहुत अच्छा संकेत @Shebang। धन्यवाद

— ElPedro

आह, मैं भूल गया कि खाली तार झूठा है। आप इसे बनाकर अन्य 3 बाइट्स बचा सकते हैं elif b:;)

— केडी

0

सी #, 74 बाइट्स

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

जोहान कार्लज़सन ने जावास्क्रिप्ट के लिए किया था, गाड़ी के रिटर्न के साथ अंकों के 1 सेट को, अंकों के सेट और एक और गाड़ी के रिटर्न के साथ बदलें।

— Grax32
स्रोत

उत्पाद सूचि

पर्ल, 12 बाइट्स

एपीएल, 18

रेटिना , 28 14 10 8 बाइट्स

हास्केल, 36 बाइट्स (रेगेक्स नहीं)

जावास्क्रिप्ट, 38 36 बाइट्स

उदाहरण

जावास्क्रिप्ट (ईएस 6), 28 26 बाइट्स

उदाहरण

भीम, १ , १२ अक्षर

पायथन 2, 40 बाइट्स

05AB1E ,39 37 16 बाइट्स

जावास्क्रिप्ट (ईएस 6), 36 बाइट्स

उदाहरण

जावा 7, 200 185 174 167 बाइट्स

सी #, 191 177 बाइट्स

PHP, 48 बाइट्स

MATLAB, 81 73 बाइट्स

व्याख्या

रूबी, 28 बाइट्स

jq, 47 अक्षर

PHP, 61 59 56 55 बाइट्स

संपादित करें

जावास्क्रिप्ट रेगेक्स के बिना, 84 81 79 बाइट्स

गणितज्ञ, 39 बाइट्स

रैकेट 274 बाइट्स

आर, 63 52 बाइट्स

जेली , 14 बाइट्स

कैसे?

सी, 107 बाइट्स

अजगर 2, 103 94 88 बाइट्स

सी #, 74 बाइट्स