En utilisant nos symboles mathématiques familiers: +, x, parenthèses et tout nombre rationnel, il est facile de créer des expressions qui évaluent un certain nombre souhaité. Par exemple: 1+(2x3)=7, (1+2)+(3x6.5)=22.5et ainsi de suite. Assez ennuyeux.

Dans ce défi, nous allons utiliser un nouvel opérateur: ±. L'utilisation de ±dans une expression signifie que vous devez évaluer l'expression en remplaçant le ±s par +ou -de toutes les manières possibles, et renvoyer l'ensemble de toutes les valeurs possibles. Par exemple:

• 1±2±3 = {-4,0,2,6}parce que 1±2±3peut être l' un 1+2+3, 1+2-3, 1-2+3et 1-2-3et leurs valeurs sont 6,0,2,-4respectivement.
• (±2)x(2±3) = {-10,-2,2,10} pour des raisons similaires.

Maintenant, il se trouve que , étant donné un ensemble de nombres réels distincts, il est possible de créer une expression avec +, x, (, ), ±et des nombres réels qui permet d' évaluer à l'ensemble donné.

Tâche

Votre tâche est d'écrire un programme ou une fonction dans une langue de votre choix, qui prend une séquence (liste / série / tout format pratique) des entiers et génère une expression (comme une chaîne) comprenant +, x, (, ), ±et nombres rationnels qui évalue à l'ensemble des nombres donnés.

• Notez que le caractère exact ±n'a pas d'importance; vous pouvez utiliser tout autre personnage de votre choix tant qu'il se distingue des autres personnages que vous utilisez. Mais vous devez mentionner quel personnage vous utilisez dans votre soumission.
• L'entrée peut consister en approximations décimales (jusqu'à une précision raisonnable) des nombres rationnels utilisés.
• L'entrée et la sortie peuvent être prises de n'importe quelle manière standard.
• Les failles standard sont interdites.
• Vous pouvez supposer que les entiers donnés seront distincts et fournis dans l'ordre croissant.
• La sortie peut contenir des espaces et des retours à la ligne.

Critère gagnant

C'est le code-golf , donc le code le plus court en octets gagne.

Exemples

Entrée | Sortie possible
------------- + -----------------------------
[1,2,3] | 2 ± 0,5 ± 0,5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{Idée tirée d'une question du Tournoi des villes, automne 2015 .}

Python 2 , 56 octets

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

Essayez-le en ligne!

Le ?représente ±. Exemple d'utilisation:

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

L'idée est que nous pouvons prendre une expression Eet attacher une nouvelle valeur hà son ensemble de valeurs en faisant (.5±.5)*(E+-h)+h.

Haskell , 52 octets

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

Essayez-le en ligne!

Utilise ?pour ±. Exemple:

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

La fonction le showsfait shows a b=(show a)++b, une astuce que j'ai apprise de Lynn.

shows 12 "abc" ->
"12abc"

Haskell , 58 octets

En utilisant # de ±, car c'est un octet de moins.

f prend une liste d'entiers et renvoie une chaîne.

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

Le résultat est de la forme n+(.5#.5)x(rest), où nest le premier élément de la liste etrest est la représentation de tous les autres avec nsoustrait de chacun.

Essayez-le en ligne!

Gelée , 29 octets

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

Imprime v + (0,5¤0,5) × (i ₁ + (0,5¤0,5) × ((i ₂ + (0,5¤0,5) × (... (i _n ) ...))) où v est le premier nombre de le tableau d'entrée et i _n est le n ^ème différence incrémentale entre les éléments du tableau d'entrée.

Essayez-le en ligne!

Comment?

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

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

Essayez-le en ligne!

Explication

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

Construire l'expression à partir de la droite se termine malheureusement avec le même nombre d'octets
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ). Les 8 octets utilisés pour la configuration sont le gros gaspillage ici.

Haskell, 54 octets

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

le signe + - est '?'. Exemple:

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

JavaScript (ES6), 56 51 octets

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

Basé sur la formule de @ JonathanAllan. @représente ±.