Trong thử thách này, bạn sẽ sử dụng để phân phối một sản phẩm qua các khoản tiền và sự khác biệt về số lượng, như được giải thích ở đây .

Ví dụ

  Input      |     Output
-------------|-------------
23(12+42)    | (23*12)+(23*42)
9(62-5)      | (9*62)-(9*5)
4(17+8-14)   | (4*17)+(4*8)-(4*14)
15(-5)       | -(15*5)
2(3)         | (2*3)
8(+18)       | +(8*18)
8(-40+18)    | -(8*40)+(8*18)

Sự chỉ rõ

Đầu vào sẽ là một chuỗi có dạng n(_), với một số nguyên không dấu dương duy nhất ntheo sau là một biểu thức được ngoặc đơn _. Biểu thức _này sẽ bao gồm các khoản tiền và sự khác biệt của một trong các thuật ngữ số nguyên dương hơn được phân tách bằng +và -dấu hiệu. Thuật ngữ đầu tiên có thể được đi trước bởi một +dấu hiệu, một -dấu hiệu hoặc không có dấu hiệu.

Trong đầu ra, số lượng ban đầu nnên được phân phối để nhân từng điều khoản. Mỗi thuật ngữ anên được nhân trái - để nhân nbiểu thức được ngoặc đơn (n*a)và các thuật ngữ mới này phải được kết hợp với +và -ký hiệu theo cách chính xác giống như các thuật ngữ ban đầu.

Đầu vào không hợp lệ

Đây là những ví dụ về đầu vào mà bạn không phải xử lý.

3(5 plus 3)
6(5 13)
(5+8)(6+6)
(5+3)8

Chiến thắng

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

Pip, 28 byte

DQaUnxWa^'(xR`\d+`'(.n.`*&)`

Giải trình:

                              a is first cmdline arg (implicit)
DQa                           Remove (DeQueue) the closing paren from a
   UnxWa^'(                   Unify n and x with a split on open paren--Python equivalent
                                n,x=a.split("(")
                              n is thus the number to be distributed, and x is the
                                addition/subtraction expression
           xR                 In x, replace...
             `\d+`            ... regex matching numbers...
                  '(.n.`*&)`  ... with the replacement pattern (n*&), where n is the
                                appropriate number and & substitutes the complete match
                              Print result (implicit)

Các đối tượng Mẫu của Pip hầu hết tuân theo cú pháp regex của Python, nhưng &mẫu thay thế được mượn từ sed.

Tìm hiểu thêm về Pip tại kho Github

JavaScript 65 byte

s=>(q=s.split(/[()]/))[1].replace(/(\D?)(\d+)/g,`$1(${q[0]}*$2)`)

Điều này sẽ mất đầu vào. Lấy dấu + hoặc -, sau đó là các chữ số, sau đó thay thế nó theo đúng thứ tự.

Giải trình

s=>   // Function with argument "s"
  (q= // Set q to...
    s.split(/[()]/) // Splits on parenthesis, returns array
  )
  [1] // Gets second match or text inside brackets
  .replace(/ // Replaces string 
     (\D?)  // Try to match a non-digit, the +-/* (group 1)
     (\d+)  // Then match one or more digits (group 2)
  /,
      // $1 is group 1 and $2 is group 2 q[0] is the text before the parenthesis 
  `$1(${q[0]}*$2)`
  ) 

Sử dụng

Điều này chỉ hoạt động trong Firefox và Safari Nightly có thể Edge? bởi vì nó sử dụng các tính năng ES6. Bạn có thể chạy nó bằng cách:

var t = s => (q = s.split (/ [()] /)) [1] .replace (/ (\ D?) (\ d +) / g, `$ 1 ($ {q [0]} * $ 2) `)

t ( "5 (-6 + 7 + 3-8 + 9)" ); // - (5 * 6) + (5 * 7) + (5 * 3) - (5 * 8) + (5 * 9)

Python 2.7, 110 108 byte

import re
p=re.findall('([+-]?)(\d+)',raw_input())
print"".join("%s(%s*%s)"%(e[0],p[0][1],e[1])for e in p[1:])

Chương trình lấy đầu vào từ stdin, tìm kiếm các kết quả khớp với - ([+-]?)(\d+)regex và tạo chuỗi đầu ra.
Kiểm tra nó -

<< 23(12+42)
>> (23*12)+(23*42)

<< 9(62-5)
>> (9*62)-(9*5)

<< 4(17+8-14)
>> (4*17)+(4*8)-(4*14)

<< 15(-5)
>> -(15*5)

<< 2(3)
>> (2*3)

<< 8(+18)
>> +(8*18)

<< 8(-40+18)
>> -(8*40)+(8*18)

Võng mạc , 40 byte

+`(\d+)\((\D)?(\d+)
$2($1*$3)$1(
\d+..$
<empty line>

Mỗi dòng nên đi đến tệp riêng của nó nhưng bạn có thể chạy mã dưới dạng một tệp có -scờ. Ví dụ:

>echo -n "8(-40+18)"|retina -s distributing_numbers
-(8*40)+(8*18)

Hai dòng đầu tiên đẩy số nhân bên cạnh mỗi số ở dạng dự kiến:

8(-40+18)
-(8*40)8(+18)
-(8*40)+(8*18)8()

Hai dòng cuối cùng loại bỏ phần đuôi không cần thiết:

-(8*40)+(8*18)8()
-(8*40)+(8*18)

sed, 105 byte

Chỉ muốn xem nếu điều này có thể được thực hiện với sed.
Có thể một chút trường học cũ, nhưng nó hoạt động.

$ cat distnum.sed
s@\([0-9]*\)(\([0-9]*\)\([+-]*\)\([0-9]*\)\([+-]*\)\([0-9]*\))@(\1*\2)\3(\1*\4)\5(\1*\6)@
s@([0-9]*\*)@@g

$ cat distnum.txt
23(12+42)
9(62-5)
4(17+8-14)
15(-5)
2(3)
8(+18)
8(-40+18)

$ sed -f distnum.sed distnum.txt
(23*12)+(23*42)
(9*62)-(9*5)
(4*17)+(4*8)-(4*14)
-(15*5)
(2*3)
+(8*18)
-(8*40)+(8*18)

rs , 77 byte

$$d=(?<!\))([+-]?)(\d+)
+$d\($d([+-])/\3(\1\2*\4)\5\1\2(
$d\($d\)/\3(\1\2*\4)

Bản demo trực tiếp và tất cả các trường hợp thử nghiệm.

Đây là lần đầu tiên macro của rs thực sự được sử dụng!

ĐĂNG KÝ , 45 byte

Sử dụng REGXY, một ngôn ngữ dựa trên thay thế regex.

/(\d+)\((\D)?(\d+)/\2(\1*\3)\1(/
//
/\d+\(.//

Perl, 36 byte

Mã 35 byte + dòng lệnh 1 byte

($a,$_)=split/[()]/;s/\d+/($a*$&)/g

Sử dụng:

echo "4(17+8-14)" | perl -p entry.pl

Bình thường, 39 38 byte

Một giải pháp regex khủng khiếp:

P:eJcz\("([+-]?)(\d+)"X"\\1(_*\\2)"3hJ

Ruby, 94 byte

gets.scan(/(\d+)\(([[-+]?\d+]+)/){|a,b|b.scan(/([-+]?)(\d+)/).map{|c,d|$><<"#{c}(#{a}*#{d})"}}

CJam, 50 byte

l__'(#_@<'*+@@)>);'+/'-f/\ff{1$'(@@++')+L?}'-f*'+*

Dùng thử trực tuyến

CJam không có hỗ trợ regex, hoặc bất cứ điều gì ngoài việc tìm kiếm và phân tách chuỗi rất thuận tiện cho việc phân tích cú pháp biểu thức. Vì vậy, có một số lao động liên quan ở đây.

Giải trình:

l__   Get input and push 2 copies for splitting.
'(#   Find index of '(.
_     Copy index, will be used twice.
@<    Get one copy of input to top, and slice to get first multiplier.
'*+   Append '* to first multiplier.
@@    Get another copy of input and '( index to top.
)>    Increment and slice to get everything after '(.
);    Remove trailing ').
'+/   Split at '+.
'-f/  Split each part at '-.
\     Swap first multiplier to top.
ff{   Apply block to nested list of second multipliers.
  1$    Copy term. Will use this copy as condition to skip empty second multipliers
        that result from unary + or -.
  '(    Opening parentheses.
  @@    Get first and second multiplier to top.
  ++    Concatenate it all.
  ')+   Concatenate closing parentheses.
  L     Push empty string for case where term is skipped.
  ?     Ternary if to pick term or empty string.
}     End of loop over list of second multipliers.
'-f*  Join sub-lists with '-.
'+*   Join list with '+.

chim ưng - 60 58

$0=gensub(/(.*\()?(+|-)?([0-9]+))?/,"\\2("$0+0"*\\3)","G")

Phew ... đã không làm việc với regrec trong một thời gian dài.

Perl 5, 70 60 55 44 Byte + 1 hình phạt

Một giải pháp perl chỉ sử dụng chia và 1 biểu thức chính quy.
Cũng tính toán các đầu vào dài hơn.

($a,$_)=split/[()]/;s/(\D?)(\d+)/$1($a*$2)/g

Kiểm tra

$ echo "8(9-10+11-12+13-14)"|perl -p distnums.pl   
(8*9)-(8*10)+(8*11)-(8*12)+(8*13)-(8*14)

Một phiên bản có tham số

($a,$_)=split/[()]/,pop;s/(\D?)(\d+)/$1($a*$2)/g;print

Một phiên bản chỉ sử dụng các biểu thức thông thường.

s/(\d+)\((.*)\)/$2:$1/;s/(\D?)(\d+)(?=.*:(\d+)).*?/$1($3*$2)/g;s/:.*//

Cái này hoạt động thông qua một nhóm chụp trong một cái nhìn tích cực và kết hợp lười biếng. Có lẽ đã sử dụng một cái nhìn tích cực nếu Perl 5 hỗ trợ nó, nhưng than ôi. Mất một lúc tôi mới nhận ra rằng điều này là có thể với regex.

Võng mạc , 50 51 43 byte

Tôi nghĩ rằng đây có thể là chương trình Retina đầu tiên của tôi. Nếu không, đó là chương trình Retina đầu tiên của tôi phức tạp (thực sự không phức tạp.) Mỗi ​​dòng đi trong tệp riêng của nó.

+`(\d+)\((\D?)(\d+)
$1($'$2($1*$3)
.+?\)
$'

Tôi đã không thực sự kiểm tra điều này với Retina, tôi đã thử nghiệm nó bằng cách sử dụng trình kiểm tra thay thế regex nhiều lần, nhưng nó sẽ hoạt động.

Mô tả cho ví dụ đầu tiên:

Vì có số lượng tệp chẵn, Retina sử dụng chế độ thay thế. Thay thế đầu tiên (hai tệp đầu tiên) sẽ xóa một số được phân phối và thêm cặp phân phối đó (23*12)vào cuối, cho 23(+42)(23*12). +`khi bắt đầu yêu cầu Retina liên tục thay thế cho đến khi mẫu không khớp và vì mẫu này được khớp lại, mẫu sẽ thay thế mẫu này bằng 23()(23*12)+(23*42). Điều này không còn phù hợp nữa, vì vậy 2 tệp tiếp theo được sử dụng cho lần thay thế tiếp theo. Lần này, nó chỉ đơn giản là loại bỏ 23(). Điều này hoạt động độc đáo: vì các sản phẩm được gắn vào cuối, tôi không phải làm bất cứ điều gì kỳ lạ nếu một số không có dấu, vì số duy nhất không có dấu là số đầu tiên.

EDIT: $'thay thế đại diện cho phần còn lại của chuỗi sau trận đấu, vì vậy tôi có thể loại bỏ các dấu (.*).

k, 98 byte

Không chơi gôn lắm.

{,/(*x){(s#y),("*"/:(x;(s:(*y)in"+-")_y))/:$"()"}/:1_x@:&~~#:'x:((0,&~x in .Q.n)_x){x_'x?'y}/"()"}

Tách trên không chữ số, loại bỏ parens, loại bỏ các chuỗi trống, sau đó giữ xhằng số là chuỗi đầu tiên, kết hợp *với từng chuỗi còn lại y, dấu ngoặc đơn và di chuyển dấu hiệu về đầu nếu có; san phẳng đầu ra thành một chuỗi duy nhất.