Trong Vim, bạn có thể lặp lại một lệnh bằng cách đặt trước nó với một số, giống như 3ddtương đương với dd dd dd. Chà, mẫu lặp lại này không bị hạn chế đối với các lệnh Vim. Chuỗi có thể được nhân rộng theo cách này, quá.

Sự chỉ rõ:

Đưa ra một chuỗi, chỉ bao gồm các chữ số, ký tự chữ cái (cả chữ hoa và chữ thường) và dấu cách, với một dòng mới tùy chọn, làm đầu vào, viết một chương trình thực hiện công việc sau:

• Mỗi "từ" bao gồm các chữ số và bảng chữ cái. Nếu một chữ cái đứng trước một số (có thể có nhiều hơn một chữ số trong một số hoặc số đó bằng 0), hãy lặp lại chữ cái đó cho các lần đã cho. Ví dụ:

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

• Các từ được phân cách bằng dấu cách. Có tối đa một khoảng trắng giữa mỗi hai từ liền kề.

Dễ thôi phải không? Đây là những thứ bổ sung:

• Nếu có một số trước khoảng trắng, lặp lại từ tiếp theo cho các lần nhất định. Số sẽ luôn được gắn vào cuối từ trước hoặc ở đầu chuỗi. Thí dụ:

  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
  

• Nếu một từ trống phải được lặp lại, không xuất ra nhiều khoảng trắng trong một hàng. Bóp chúng:

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

  Nói cách khác, chương trình của bạn không bao giờ nên xuất hai khoảng trắng với nhau.

• Đầu vào không bao giờ trống, nhưng không cần thiết đầu ra không trống:

  0 3x -> (empty)
  

• Đầu vào và đầu ra có thể được thực hiện theo bất kỳ cách ưa thích. Một hàm lấy đầu vào từ các đối số và đưa ra đầu ra thông qua các giá trị trả về cũng được chấp nhận.

  Nếu đó là một chương trình, nó không được thoát với lỗi (tức là giá trị trả về bằng 0).

• Các số luôn là số thập phân và không bao giờ bắt đầu bằng số 0, trừ khi bản thân số đó bằng 0, trong trường hợp đó chỉ có một số không. Tức là bạn không cần phải xem xét 077ahoặc 000ađưa ra làm đầu vào.

• Tất cả các số dưới 2 ^ 31 (2.147.483.648). Độ dài đầu ra tối đa dưới 2 ^ 32 (4.294.967.296) byte.

• Chương trình có thể tùy ý xuất ra một dấu cách và / hoặc một dòng mới. Những không gian và dòng mới không ảnh hưởng đến tính hợp lệ của đầu ra. Ngay cả khi đầu ra chính xác phải trống, đầu ra của khoảng trắng theo dòng mới sẽ đủ điều kiện.

Nói tóm lại, một đầu vào hợp lệ khớp với biểu thức chính quy này:

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

Và cho một đầu ra hợp lệ:

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

Các trường hợp thử nghiệm mẫu:

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

Đây là một môn đánh gôn , vì vậy chương trình ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng!

JavaScript (Node.js) , 102 129 110 106 byte

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

Hãy thử trực tuyến!

Cảm ơn @Arnauld cho -4 byte.

Perl 6, 88 byte

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

Kiểm tra nó

Mở rộng:

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

Sự ~(…).wordskết hợp sẽ loại bỏ các khoảng trắng bên ngoài, điều này rất hữu ích nếu một từ bị xóa.

Python 2, 286 275 260 257 238 byte

-19 byte nhờ vào ovs

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 lấy một chuỗi làm đối số và in chuỗi được định dạng.

Đây là một repl.it với các trường hợp thử nghiệm.

Mã bị đánh cắp:

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

Vẫn đang làm việc trên các cải tiến.

Perl 5 , 77 + 1 ( -p) = 78 byte

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

Hãy thử trực tuyến!

Sạch , 443 ... 306 byte

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

Hãy thử trực tuyến!

Lua , 113 byte

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)

Hãy thử trực tuyến!