Usando nuestros símbolos matemáticos familiares: +, x, paréntesis y cualquier número racional, es fácil crear expresiones que evalúen algún número deseado. Por ejemplo: 1+(2x3)=7, (1+2)+(3x6.5)=22.5y así sucesivamente. Bastante aburrido.

En este desafío, vamos a utilizar un nuevo operador: ±. El uso de ±en una expresión significa que necesita evaluar la expresión reemplazando la ±'s por +o -de todas las formas posibles, y devolver el conjunto de todos los valores posibles. Por ejemplo:

• 1±2±3 = {-4,0,2,6}porque 1±2±3puede ser cualquiera de 1+2+3, 1+2-3, 1-2+3y 1-2-3y sus valores son 6,0,2,-4respectivamente.
• (±2)x(2±3) = {-10,-2,2,10} por razones similares

Ahora bien, como resulta que, dado cualquier conjunto de números reales distintos, es posible crear una expresión con +, x, (, ), ±, y los números reales que se evalúa como el conjunto dado.

Tarea

Su tarea es escribir un programa o función en un idioma de su elección, que lleva una secuencia (lista / serie / cualquier formato conveniente) de números enteros y da salida a una expresión (como una cadena) que consiste en +, x, (, ), ±, y los números racionales que evalúa el conjunto de los números dados.

• Tenga en cuenta que el carácter exacto ±no importa; puedes usar cualquier otro personaje de tu elección siempre que sea distinguible de los otros personajes que estás usando. Pero debe mencionar qué personaje está utilizando en su presentación.
• Se permite que la entrada consista en aproximaciones decimales (hasta una precisión razonable) de los números racionales utilizados.
• La entrada y salida se pueden tomar de cualquiera de las formas estándar.
• Las lagunas estándar están prohibidas.
• Puede suponer que los enteros dados serán distintos y se proporcionarán en orden creciente.
• La salida puede contener espacios y líneas nuevas.

Criterio ganador

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

Ejemplos

Entrada | Salida posible
------------- + -----------------------------
[1,2,3] | 2 ± 0.5 ± 0.5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{Idea tomada de una pregunta en el Torneo de Ciudades, Otoño 2015 .}

Python 2 , 56 bytes

f=lambda h,*t:t and"(.5?.5)*(%s+%%s)+"%f(*t)%-h+`h`or`h`

Pruébalo en línea!

Los ?soportes para ±. Ejemplo de uso:

f(-3,5,20) ->
(.5?.5)*((.5?.5)*(20+-5)+5+3)+-3

La idea es que podemos tomar una expresión Ey unir un nuevo valor ha su conjunto de valores haciendo (.5±.5)*(E+-h)+h.

Haskell , 52 bytes

f(h:t)=shows h"+(.5?.5)*("++f[x-h|x<-t]++")"
f e="0"

Pruébalo en línea!

Usos ?para ±. Ejemplo:

f [1,3,7] ->
1+(.5?.5)*(2+(.5?.5)*(4+(.5?.5)*(0)))

La función showssí shows a b=(show a)++b, un truco que aprendí de Lynn.

shows 12 "abc" ->
"12abc"

Haskell , 58 bytes

Usando #para ±, ya que es un byte menos.

f toma una lista de enteros y devuelve una cadena.

f[x]=show x
f(x:r)=show x++"+(.5#.5)x("++f((-x+)<$>r)++")"

El resultado es de la forma n+(.5#.5)x(rest), donde nes el primer elemento de la lista y restes la representación de todos los demás nrestados de cada uno.

Pruébalo en línea!

Jalea , 29 bytes

“(¤)”j.⁾+×j;”(
I;@Ḣj¢;”)ẋ⁸L¤¤

Imprime v + (0.5¤0.5) × (i ₁ + (0.5¤0.5) × ((i ₂ + (0.5¤0.5) × (... (i _n ) ...))) donde v es el primer número en la matriz de entrada y i _n es el n ^º diferencia incrementales entre elementos de la matriz de entrada.

Pruébalo en línea!

¿Cómo?

“(¤)”j.⁾+×j;”( - Link 1, adjoining list: no input
“(¤)”          - literal     ['(','¤',')']
      .        - literal     0.5
     j         - join        ['(',0.5,'¤',0.5,')']
       ⁾+×     - literal     ['+','×']
          j    - join        ['+',['(',0.5,'¤',0.5,')'],'×']
            ”( - literal     '('
           ;   - concatenate ['+',['(',0.5,'¤',0.5,')'],'×','(']

I;@Ḣj¢;”)ẋ⁸L¤¤ - Main link: list a               e.g. [-1,5,2]
I              - incremental differences(a)           [6,-3]
   Ḣ           - head(a)                              [-1]
 ;@            - concatenate (rev @rgs)               [-1,6,-3]
     ¢         - last link (1) as a nilad             ['+',['(',0.5,'¤',0.5,')'],'×','(']
    j          - join                                 [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3]
             ¤ - nilad followed by link(s) as a nilad
            ¤  -     nilad followed by link(s) as a nilad
          ⁸    -         link's left argument, a
           L   -         length                       3
       ”)      -     literal ')'
         ẋ     -     repeat                           [')',')',')']
      ;        - concatenate                          [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3,')',')',')']
               - implicit print                       -1+(0.5¤0.5)×(6+(0.5¤0.5)×(-3))

05AB1E , 25 bytes

0¸«¥X;D"+(ÿ±ÿ)*("ý¹g<')×J

Pruébalo en línea!

Explicación

0¸«                        # prepend a 0 to input list
   ¥                       # calculate delta's
    X;D                    # push 0.5 twice
       "+(ÿ±ÿ)*("          # push this string and interpolate 0.5 where "ÿ" is
                 ý         # merge the list of delta's with this string as a separator
                  ¹g<')×J  # add the closing parenthesis

Desafortunadamente, construir la expresión desde la derecha termina en que el mismo byte cuenta
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ). Los 8 bytes utilizados para la configuración son el gran desperdicio aquí.

Haskell, 54 bytes

f[]="0"
f(x:s)=show x++"+(.5?.5)*("++f(map(-x+)s)++")"

el signo + - es '?'. ejemplo:

f[1,2,3,4] = "1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(0))))"

JavaScript (ES6), 56 51 bytes

f=([v,...a],x=v)=>x?x+`+(.5@.5)*(${f(a,a[0]-v)})`:0

Basado en la fórmula de @ JonathanAllan. @representa ±.