Usando i nostri familiari simboli matematici: +, x, parentesi e qualsiasi numero razionale, è facile creare espressioni che valutino il numero desiderato. Ad esempio: 1+(2x3)=7, (1+2)+(3x6.5)=22.5e così via. Abbastanza noioso.

In questa sfida, useremo un nuovo operatore: ±. L'uso di ±in un'espressione significa che è necessario valutare l'espressione sostituendo quella ±di +o -in tutti i modi possibili e restituendo l'insieme di tutti i possibili valori. Per esempio:

• 1±2±3 = {-4,0,2,6}perché 1±2±3può essere qualsiasi 1+2+3, 1+2-3, 1-2+3e 1-2-3ei loro valori sono 6,0,2,-4rispettivamente.
• (±2)x(2±3) = {-10,-2,2,10} per ragioni simili.

Ora, come risulta, in ogni insieme di numeri reali distinti, è possibile creare un'espressione con +, x, (, ), ±, e numeri reali che restituisce il set indicato.

Compito

Il vostro compito è quello di scrivere un programma o una funzione in una lingua di vostra scelta, che prende una sequenza (lista / array / qualsiasi formato conveniente) di interi ed emette un'espressione (come una stringa) composto da +, x, (, ), ±, e numeri razionali che valuta l'insieme dei numeri indicati.

• Nota che il personaggio esatto ±non ha importanza; puoi usare qualsiasi altro personaggio di tua scelta purché sia ​​distinguibile dagli altri personaggi che stai usando. Ma devi menzionare quale personaggio stai usando nella tua presentazione.
• È possibile che l'input sia costituito da approssimazioni decimali (fino a un'accuratezza ragionevole) dei numeri razionali utilizzati.
• Input e output possono essere acquisiti in uno dei modi standard.
• Sono vietate le scappatoie standard.
• Puoi presumere che i numeri interi indicati siano distinti e forniti in ordine crescente.
• L'output può contenere spazi e newline.

Criterio vincente

Questo è code-golf , quindi vince il codice più breve in byte.

Esempi

Input | Uscita possibile
------------- + -----------------------------
[1,2,3] | 2 ± 0,5 ± 0,5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{Idea tratta da una domanda del Torneo delle città, autunno 2015 .}

Python 2 , 56 byte

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

Provalo online!

Lo ?sta per ±. Esempio di utilizzo:

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

L'idea è che possiamo prendere un'espressione Ee aggiungere un nuovo valore hal suo insieme di valori facendo (.5±.5)*(E+-h)+h.

Haskell , 52 byte

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

Provalo online!

Utilizza ?per ±. Esempio:

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

La funzione shows fa shows a b=(show a)++b, un trucco che ho imparato da Lynn.

shows 12 "abc" ->
"12abc"

Haskell , 58 byte

utilizzando # per ±, poiché è un byte in meno.

f prende un elenco di numeri interi e restituisce una stringa.

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

Il risultato è il modulo n+(.5#.5)x(rest), dove nè il primo elemento dell'elenco erest è la rappresentazione di tutti gli altri con nsottratto da ciascuno.

Provalo online!

Gelatina , 29 byte

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

Stampa v + (0,5¤0,5) × (i ₁ + (0,5¤0,5) × ((i ₂ + (0,5¤0,5) × (... (i _n ) ...))) dove v è il primo numero in la matrice di ingresso ed i _n è il n ^° differenza incrementale tra elementi della matrice di input.

Provalo online!

Come?

“(¤)”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 byte

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

Provalo online!

Spiegazione

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

Costruire l'espressione da destra purtroppo finisce con lo stesso conteggio dei byte
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ). Gli 8 byte utilizzati per l'installazione sono il grande spreco qui.

Haskell, 54 byte

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

il segno + è '?'. esempio:

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

JavaScript (ES6), 56 51 byte

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

Basato sulla formula di @ JonathanAllan. @sta per ±.