在这个挑战，你会使用BE 分配了金额和数量的不同产品，如解释在这里。

例子

  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)

规格

输入将是形式为字符串的字符串n(_)，带有单个正无符号整数，n后跟一个带括号的表达式_。该表达式_将由以+和-号分隔的多个正整数项之一的和与差组成。第一项之前可以带有+符号，-符号或没有符号。

在输出中，n应分配初始数字以乘以每个项。a应该将的每个术语左乘以n产生带括号的表达式(n*a)，并且这些新术语应与+和-符号以与原始术语完全相同的方式进行组合。

输入无效

这些是您不必处理的输入示例。

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

获奖

这是代码高尔夫球，因此以字节为单位的最短代码获胜。

点，28个字节

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

说明：

                              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)

Pip的Pattern对象大多遵循Python regex语法，但是&替换模式是从sed借用的。

在Github存储库中了解有关Pip的更多信息

JavaScript 65字节

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

这将接受输入。获取+或-，然后获取数字，然后以正确的顺序替换它。

说明

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

用法

这仅适用于Firefox和Safari Nightly Edge吗？因为它使用ES6功能。您可以通过以下方式运行它：

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字节

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

该程序从stdin中获取输入，针对-regex搜索匹配项([+-]?)(\d+)并创建输出字符串。
测试-

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

视网膜，40字节

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

每一行都应转到其自己的文件，但是您可以将代码作为带有-s标志的一个文件来运行。例如：

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

前两行将乘数按预期形式推到每个数字旁边：

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

最后两行删除了不必要的尾随部分：

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

sed，105个字节

只想看看这是否可以用sed完成。
也许有点老派了，但是行得通。

$ 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字节

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

现场演示和所有测试用例。

这是第一次真正使用rs的宏！

REGXY，45个字节

使用REGXY，这是一种基于正则表达式替换的语言。

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

Perl，36个字节

35字节代码+ 1字节命令行

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

用法：

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

Pyth，39 38字节

一个糟糕的正则表达式解决方案：

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

Ruby，94个字节

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

CJam，50个字节

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

在线尝试

CJam不提供正则表达式支持，或除字符串搜索和拆分之外的任何其他对表达式分析非常方便的支持。因此，这里涉及一些劳动。

说明：

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 '+.

鹰嘴-60 58

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

ew ...很长时间没有使用regexp了。

Perl 5中，70 60 55 44个字节+ 1个罚分

一个仅使用split和1正则表达式的perl解决方案。
同时计算较长的输入。

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

测试

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

带有参数的版本

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

仅使用正则表达式的版本。

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

这是通过正向超前匹配和惰性匹配中的捕获组工作的。如果Perl 5支持的话，可能会采用积极的态度。花了我一段时间才发现正则表达式可以实现这种功能。

视网膜，50 51 43字节

我认为这可能是我的第一个Retina程序。如果没有，那么这就是我的第一个Retina程序，它就是这么复杂（实际上并不是那么复杂）。每一行都放在自己的文件中。

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

我实际上并未使用Retina进行测试，而是使用正则表达式替换测试器对其进行了多次测试，但它应该可以正常工作。

第一个示例的说明：

由于文件数量偶数，因此Retina使用替换模式。第一个替换（前两个文件）删除要分配的数字，并将该分配对添加(23*12)到末尾，给出23(+42)(23*12)。+`开始时会告诉Retina重复替换，直到模式不匹配为止，并且由于再次匹配，因此模式将替换为23()(23*12)+(23*42)。不再匹配，因此接下来的2个文件用于下一次替换。这次，它只是删除了23()。效果很好：由于产品会附加在末尾，因此如果数字没有符号，我就不需要做任何奇怪的事情，因为唯一没有符号的数字就是第一个数字。

编辑：$'替换中表示比赛后字符串的其余部分，因此我可以删除结尾的(.*)s。

k，98个字节

不太打高尔夫球。

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

按非数字拆分，删除括号，删除空字符串，然后将x常量作为第一个字符串，并*与其余的每个字符串y，括号括起来，如果有则将符号移到开头；将输出展平为单个字符串。