En este desafío, estará utilizando distribuir un producto sobre sumas y diferencias de números, como se explica aquí .

Ejemplos

  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)

Especificación

La entrada será una cadena de la forma n(_), con un solo entero positivo sin signo nseguido de una expresión entre paréntesis _. Esta expresión _consistirá en sumas y diferencia de uno o más términos enteros positivos separados por signos +y -. El primer término puede estar precedido por un +signo, un -signo o por ningún signo.

En la salida, el número inicial ndebe distribuirse para multiplicar cada uno de los términos. Cada término de adebe multiplicarse na la izquierda por para producir la expresión entre paréntesis (n*a), y estos nuevos términos deben combinarse con +y -signos exactamente de la misma manera que los términos originales.

Entradas inválidas

Estos son ejemplos de entradas que no tiene que manejar.

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

Victorioso

Este es el código de golf , por lo que gana el código más corto en bytes.

Pip, 28 bytes

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

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

Los objetos de Patrón de Pip siguen principalmente la sintaxis de expresiones regulares de Python, pero el &patrón de reemplazo se toma prestado de sed.

Lea más sobre Pip en el repositorio de Github

JavaScript 65 bytes

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

Esto tomará la entrada. Obtenga el + o -, luego los dígitos, luego reemplácelos en el orden correcto.

Explicación

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

Uso

Esto solo funciona en Firefox y Safari Nightly ¿ quizás Edge? porque usa las funciones de ES6. Puedes ejecutarlo de la siguiente manera:

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 bytes

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

El programa toma la entrada de stdin, busca coincidencias contra - ([+-]?)(\d+)regex y crea la cadena de salida.
Probándolo

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

Retina , 40 bytes

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

Cada línea debe ir a su propio archivo, pero puede ejecutar el código como un archivo con la -sbandera. P.ej:

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

Las primeras dos líneas empujan el multiplicador al lado de cada número en la forma esperada:

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

Las dos últimas líneas eliminan la parte final innecesaria:

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

sed, 105 bytes

Solo quería ver si esto se puede hacer con sed.
Quizás un poco vieja escuela, pero funciona.

$ 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 bytes

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

Demostración en vivo y todos los casos de prueba.

¡Es la primera vez que se usan las macros de rs!

REGXY , 45 bytes

Utiliza REGXY, un lenguaje basado en la sustitución de expresiones regulares.

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

Perl, 36 bytes

Código de 35 bytes + línea de comando de 1 byte

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

Uso:

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

Pyth, 39 38 bytes

Una terrible solución de expresiones regulares:

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

Ruby, 94 bytes

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

CJam, 50 bytes

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

Pruébalo en línea

CJam no tiene soporte para expresiones regulares, ni nada más allá de la búsqueda y división de cadenas que es muy conveniente para analizar expresiones. Entonces hay algo de trabajo involucrado aquí.

Explicación:

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

gawk - 60 58

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

Uf ... no he trabajado con expresiones regulares en mucho tiempo.

Perl 5, 70 60 55 44 Bytes + 1 penalización

Una solución perl que solo usa división y 1 expresión regular.
También calcula las entradas más largas.

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

Prueba

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

Una versión que toma un parámetro

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

Una versión que solo usa expresiones regulares.

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

Éste funciona a través de un grupo de captura dentro de una búsqueda anticipada positiva y una coincidencia perezosa. Probablemente habría usado una mirada positiva hacia atrás si Perl 5 lo admitiera, pero desgraciadamente. Me tomó un tiempo darme cuenta de que esto es posible con regex.

Retina , 50 51 43 bytes

Creo que este puede ser mi primer programa de Retina. Si no, es mi primer programa Retina que es tan complejo (no tan complejo, en realidad). Cada línea va en su propio archivo.

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

En realidad no probé esto con Retina, lo probé usando un probador de reemplazo de expresiones regulares varias veces, pero debería funcionar.

Descripción para el primer ejemplo:

Como hay un número par de archivos, Retina usa el modo de reemplazo. El primer reemplazo (primeros dos archivos) elimina un número que se distribuirá y agrega ese par de distribución (23*12)al final, dando 23(+42)(23*12). +`al principio le dice a Retina que reemplace repetidamente hasta que el patrón no coincida, y dado que esto coincide nuevamente, el patrón reemplaza esto con 23()(23*12)+(23*42). Esto ya no coincide, por lo que los siguientes 2 archivos se usan para el próximo reemplazo. Esta vez, simplemente elimina el 23(). Esto funciona bien: dado que los productos se agregan hasta el final, no tengo que hacer nada extraño si un número no tiene un signo, ya que el único que puede estar sin un signo es el primer número.

EDITAR: $'en reemplazo representa el resto de la cadena después del partido, por lo que puedo eliminar los (.*)s finales .

k, 98 bytes

No muy golfizado.

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

Dividir en no dígitos, eliminar parens, eliminar cadenas vacías, luego mantener xconstante como la primera cadena, combinar *con cada cadena restante y, paréntesis y mover el signo al principio si está presente; aplanar la salida en una sola cadena.