स्ट्रिंग प्रतिकृति

Question

विम में, आप एक संख्या को पूर्व की तरह एक कमांड दोहरा सकते हैं, जैसे 3dd कि इसके बराबर है dd dd dd। खैर, यह दोहराव पैटर्न विम आज्ञाओं तक सीमित नहीं है। स्ट्रिंग को इस तरह से भी दोहराया जा सकता है।

विशिष्टता:

एक स्ट्रिंग को देखते हुए, केवल अंकों, वर्णमाला वर्णों (ऊपरी-ऊपरी और निचले-मामले दोनों) और रिक्त स्थान से युक्त, एक वैकल्पिक अनुगामी न्यूलाइन के साथ, इनपुट के रूप में, एक प्रोग्राम लिखें जो निम्न कार्य करता है:

• प्रत्येक "शब्द" में अंक और अक्षर होते हैं। यदि कोई अक्षर एक संख्या से पहले है (एक संख्या में एक से अधिक अंक हो सकते हैं, या संख्या शून्य है), उस पत्र को दिए गए समय के लिए दोहराएं। उदाहरण के लिए:

  a2bc -> abbc
  3xx1yz -> xxxxyz
  10ab0c0d0e -> aaaaaaaaaab # No 'cde' because there's a zero
  2A2a2A2a -> AAaaAAaa
  

• शब्दों को रिक्त स्थान द्वारा अलग किया जाता है। प्रत्येक दो आसन्न शब्दों के बीच अधिकतम एक स्थान होता है।

आसान है, है ना? यहाँ अतिरिक्त सामान है:

• यदि स्थान से पहले कोई संख्या है, तो दिए गए समय के लिए अगला शब्द दोहराएं। संख्या हमेशा पिछले शब्द के अंत में, या स्ट्रिंग की शुरुआत में संलग्न होगी। उदाहरण:

  a2bc3 2d -> abbc dd dd dd
  3 3a -> aaa aaa aaa
  33a -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  0 abcd0 efgh3 2x -> xx xx xx
  a3 0xc b -> a c c c b
  

• यदि एक खाली शब्द दोहराया जाना चाहिए, तो एक पंक्ति में कई रिक्त स्थान का उत्पादन न करें। उन्हें स्क्वाश करें:

  a3 0x2 b -> a b b   # NOT 'a    b b'
  

  दूसरे शब्दों में, आपके प्रोग्राम को कभी भी दो स्थानों को एक साथ आउटपुट नहीं करना चाहिए।

• इनपुट कभी खाली नहीं होता है, लेकिन आउटपुट के गैर-रिक्त होने के लिए यह आवश्यक नहीं है:

  0 3x -> (empty)
  

• इनपुट और आउटपुट को किसी भी पसंदीदा तरीके से लिया जा सकता है। तर्कों से इनपुट लेने और रिटर्न वैल्यू के जरिए आउटपुट देने के साथ ही एक फंक्शन स्वीकार्य है।

  यदि यह एक कार्यक्रम है, तो इसे त्रुटि के साथ बाहर नहीं निकलना चाहिए (यानी रिटर्न मान शून्य है)।

• संख्या हमेशा दशमलव होती है, और कभी भी शून्य से शुरू नहीं होती है, जब तक कि संख्या स्वयं शून्य नहीं होती है, उस स्थिति में केवल एक शून्य होता है। यानी आपको इनपुट के रूप में विचार करने 077aया 000aदिए जाने की आवश्यकता नहीं है ।

• सभी नंबर 2 ^ 31 (2,147,483,648) के अंतर्गत हैं। अधिकतम उत्पादन लंबाई 2 ^ 32 (4,294,967,296) बाइट्स के अंतर्गत है।

• कार्यक्रम वैकल्पिक रूप से एक अनुगामी स्थान और / या एक अनुगामी न्यूलाइन का उत्पादन कर सकता है। वे स्थान और न्यूलाइन आउटपुट की वैधता को प्रभावित नहीं करते हैं। यहां तक ​​कि अगर सही आउटपुट खाली होना चाहिए, तो एक नईलाइन द्वारा पीछा किए गए स्थान का एक आउटपुट योग्य होगा।

संक्षेप में, एक वैध इनपुट इस नियमित अभिव्यक्ति से मेल खाता है:

([0-9]+ )?([0-9A-Za-z]*[A-Za-z])([0-9]* [0-9A-Za-z]*[A-Za-z])*( ?\n?)

और एक वैध उत्पादन के लिए:

([A-Za-z]+)( [A-Za-z]+)*( ?\n?)

नमूना परीक्षण के मामले:

abcdefg -> abcdefg
a3bcd -> abbbcd
a3bbbc -> abbbbbc
3a0b -> aaa
abc 3d -> abc ddd
abc3 d -> abc d d d
5 1x5 1y0 z -> x x x x x y y y y y
a999 0x b -> a b
999 0s -> (empty)
0 999s -> (empty)
0 999s4 t -> t t t t
a3 0xc b -> a c c c b
ABC3 abc -> ABC abc abc abc

यह एक कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है!

Comments

.... "प्रोग्राम को त्रुटि के साथ बाहर नहीं निकलना चाहिए" "चरित्र की सूची के रूप में इनपुट नहीं दिया जाना चाहिए ..." कोई विशेष कारण? (जैसा कि आप पहले से जानते थे) हम आम तौर पर लचीले I / O प्रारूप की अनुमति देते हैं।

— user202729

@ user202729 मैं बाद को हटाने पर विचार कर रहा हूं। कार्यक्रम के बाहर निकलने के परिणाम के लिए मैं इसे रखना चाहता हूं। संपादित करें : किया।

— ugगूग

समान ।

— कोल

इसके अलावा

— danieltakeshi

मुझे लगता है कि जैसे a3 0xc b-> a c c c bजोड़ा जाना चाहिए, क्योंकि मेरे पास मूल रूप से कोड था जो ऊपर दिए गए सभी परीक्षण मामलों के लिए काम करता था, लेकिन उसके लिए सही तरीके से काम नहीं किया।

— ब्रैड गिल्बर्ट 2

Answer 1

जावास्क्रिप्ट (Node.js) , 102 129 110 106 बाइट्स

s=>s[p="replace"](/(\d+)( \w*[A-Z])/gi,g=(_,a,b)=>b.repeat(a))[p](/(\d+)(.)/g,g)[p](/ +/g,(_,i)=>i?" ":"")

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

-4 बाइट्स के लिए @Arnauld के लिए धन्यवाद।

Answer 2

पर्ल 6, 88 बाइट्स

{$_=$^a;s:g/(\d+):(\w)/{$1 x$0||'_'}/;s:g/(\d+)\s([\w& \D]+)/ {$1 xx$0}/;~S:g/_//.words}

झसे आज़माओ

विस्तारित:

{ # bare block lambda with placeholder parameter ｢$a｣

  # store a copy of the argument in ｢$_｣
  # (shorter than ｢-> $_ is copy {…}｣)
  $_ = $^a;
  # note that ｢$_｣ is the default scalar,
  # and many things operate on it by default (like ｢s///｣)


  # do the character repeats
  s :global
  /

    (\d+)           # repeat count
    :               # don't backtrack (prevents it from matching word repeats)
    (\w)            # character to repeat

  /{

    $1 x $0         # do the repeat

    || '_'          # replace with ｢_｣ if the repeat was 0 (matched by [\w & \D])
                    # this is so “words” don't get removed yet

  }/;


  # do the word repeats
  s :global
  /

    (\d+)           # repeat count

    \s              # shortest way to match a space

    ([
      \w & \D       # word character and not a digit (doesn't match next repeat)
    ]+)             # match that at least once

  / {               # add a space (as we removed it by matching it)

    $1 xx $0        # list repeat (adds a space between values when stringified)

  }/;


  # the following is the result
  ~                 # stringify (adds spaces between values in a list) # (3)
    S :global /_//  # remove all _ not in-place                        # (1)
    .words          # get a list of words                              # (2)
}

~(…).wordsसंयोजन बाहरी रिक्त स्थान है, जो उपयोगी है अगर एक "शब्द" हटा दिया जाता है निकालता है।

Answer 3

पायथन 2, 286 275 260 257 238 बाइट्स

-19 बाइट्स ओव्स के लिए धन्यवाद

def f(s,j=' '.join):exec"s=s.split(%s[-1]):s[i]=s[i][:-1];s[i-1]=j([s[i-1]]*int(w[-1]))\ns=list(j(s[::-1])%s):s[i]='';s[i-1]*=int(w)\nprint j(''.join(s[::-1]).strip().split())"%((')[::-1]\nfor i,w in enumerate(s):\n if str.isdigit(w',)*2)

f एक स्ट्रिंग को एक तर्क के रूप में लेता है और स्वरूपित स्ट्रिंग को प्रिंट करता है।

यहाँ एक repl.it है परीक्षण मामलों के साथ ।

अघोषित कोड:

def f(s, j=' '.join):
    s = s.split()[::-1]
    for i, w in enumerate(s):
        if str.isdigit(w[-1]):
            s[i] = s[i][:-1]
            s[i - 1] = j([s[i - 1]] * int(w[-1]))
    s = list(j(s[::-1]))[::-1]
    for i, w in enumerate(s):
        if str.isdigit(w):
            s[i] = ''
            s[i - 1] *= int(w)
    print j(''.join(s[::-1]).strip().split())

अभी भी सुधार पर काम कर रहे हैं।

Comments

238 बाइट्स

— ovs

@ लव थैंक्स। विश्वास नहीं कर सकता कि मैंने नईलाइन से छुटकारा पाने के बारे में नहीं सोचा और इसके लिए इंडेंट किया exec, क्योंकि यह फंक्शन की एकमात्र लाइन है।

— nog642

Answer 4

पर्ल 5 , 77 + 1 ( -p) = 78 बाइट्स

s/\d+( .*?)(\d*)( |$)/$1x$&.$2.$3/eg&&redo;s/\d+(\D)/$1x$&/eg;s/ +/ /g;s;^ +;

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

Answer 5

साफ , 443 ... 306 बाइट्स

import StdEnv,StdLib
^ =last
$n|n>"9"=1=toInt n
?v c| ^v<c=init v=v
q=groupBy
f[a:t]|a<"a"=repeatn($a)(hd t)++f(tl t)|t>[]=[a:f t]=[a," "]
f e=e
@l#[h:t]=[[toString[c:if(c<'1')[]k]\\[c:k]<-q(\a b=max a b<'a')s]\\s<-q(\a b=min a b>' ')l|s>[' ']]
=flatten(map f[?h"a":[?u":"\\u<-t&v<-map^[h:t],_<-[1.. $v]]])

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

Answer 6

लुआ , 113 बाइट्स

a="(%d+)(%a)"g=a.gsub function r(c,s)return s:rep(c)end g(g(g(g(...,a,r),"(%d+)( %a*)",r)," +"," "),"%a.*",print)

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