Une expression, plusieurs valeurs


26

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 , 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 .


5
Bienvenue chez PPCG! Joli premier défi! Je pense que cela attirerait plus de réponses si c'était l'inverse (trouver l'ensemble en fonction de l'expression) car il semble que ce soit un défi assez délicat. Bon défi quand même!
HyperNeutrino

Accueillir à nouveau! En ajoutant à @HyperNeutrino, il y aura probablement plusieurs solutions à certains des ensembles, ce qui pourrait être un problème, pour décider quelle question est la "meilleure" sauf si le facteur décisif est la concision
David Archibald

@HyperNeutrino Merci! Je craignais que cela ne devienne un peu difficile, mais je crois pleinement aux capacités supérieures des golfeurs ici; Voyons comment ça se passe. :)
Ankoganit

3
Oui. Certains des golfeurs sur ce site ont des super-pouvoirs incroyables, et nous soupçonnons même que certains sont des bots de golf> _>: D
HyperNeutrino

@DavidArchibald Oui, la sortie prévue est une solution qui fonctionne.
Ankoganit

Réponses:


11

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.


Pourquoi +-h, et pas seulement-h ? Autrement dit, pourquoi ne pas faire le +a -et supprimer le -qui est actuellement dans le programme?
isaacg

1
@isaacg La spécification ne permet pas de - opérateur dans l'expression.
xnor

9

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"

5

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!


5

Gelée , 29 octets

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

Imprime v + (0,5¤0,5) × (i 1 + (0,5¤0,5) × ((i 2 + (0,5¤0,5) × (... (i n ) ...)))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))

4

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.


3

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

2

JavaScript (ES6), 56 51 octets

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

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.