Créez une fonction qui prend une équation polynomiale, une valeur pour xet renvoie le résultat de l'opération.

Exemple: donnée 4x^2+2x-5et x=3sortie 37. Ceci est le résultat de4(3)^2+2(3)-5

• Supposons que tous les polynômes sont valides
• Le format polynomial sera toujours coefficient(variable)^exponent => 4x^2sauf:
  • Lorsque l'exposant est, 1il seracoefficient(variable) => 4x
  • Lorsque le coefficient est, 1il sera(variable)^exponent => x^2
• Les polynômes sont une seule variable
• L'utilisation de bibliothèques externes est interdite
• Le coefficient et l'entrée variable peuvent être des nombres positifs et négatifs.

Cas de test

• ("3x^3-5x^2+2x-10", 5) => 250
• ("10x^4-5x^3-10x^2+3x+50", 3) => 644
• ("10x+20", 10) => 120
• ("-20x^2+20x-50", -8) => -1490
• ("9", 5) => 9
• ("8x^2+5", 0) => 5

Mise à jour

• Le format polynomial sera toujours coefficient(variable)^exponent => 4x^2sauf:
  • Lorsque l'exposant est, 1il seracoefficient(variable) => 4x
  • Lorsque le coefficient est, 1il sera(variable)^exponent => x^2
• Suppression de la règle d'exposant négatif. Mon erreur. Un polynôme valide ne contient pas d'exposant négatif
• Un exposant de 0serait justecoefficient
• Cas de test ajouté pour input 0

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

JavaScript (ES7), 48 octets

Basé sur une suggestion de @RickHitchcock

Attend Xen majuscules. Prend une entrée dans la syntaxe de curry (p)(X).

p=>X=>eval(p.replace(/[X^]/g,c=>c<{}?'*X':'**'))

Essayez-le en ligne!

JavaScript (ES7), 49 octets

Même approche que @DeadPossum . Prend une entrée dans la syntaxe de curry (p)(x).

p=>x=>eval(p.split`x`.join`*x`.split`^`.join`**`)

Essayez-le en ligne!

Python 2 , 54 octets

-2 octets grâce à Jo King

-5 octets grâce à Arnauld

lambda p,x:eval(p.replace('^','**').replace('x','*x'))

Essayez-le en ligne!

Python 3 , 53 50 48 octets

edit : -5 octets grâce à Dennis!

lambda p,x:eval(p.translate({94:"**",120:"*x"}))

Essayez-le en ligne!

Utilisé translatepour éviter de chaîner les replaceappels; La version de Python 3 translateest moins gênante que celle de son prédécesseur.

R , 44 octets

function(f,x)eval(parse(t=gsub("x","*x",f)))

Essayez-le en ligne!

Assez simple avec R. Remplacez nxpar n*xpuis evalla parsechaîne d. xest utilisé car c'est ainsi que nous nommons le deuxième argument.

La fonction eval pourrait même être plus directement utilisé avec un premier argument correctement mis en forme, et d' autres arguments formels ( y, z, etc.) pourrait être facilement ajouté:

R , 20 octets (non concurrent)

function(f,x)eval(f)

Essayez-le en ligne!

Japt 2.0, 13 octets

OvUd^'*²'x"*V

Essayez-le .

Explication:

OvUd^'*²'x"*V
              U = Implicit first input
              V = Implicit second input

Ov            Eval:
  Ud            In U, replace:
    ^             "^" with:
     '*²            "**"
        'x        "x" with:
          "*V       "*V"

Wolfram Language (Mathematica) , 22 octets

ToExpression@#/.x->#2&

Essayez-le en ligne!

JavaScript (Node.js) , 113 108 octets

_=>x=>_.match(/-?(?:[x\d]+|\^?)+/g).reduce((a,b)=>b.split`x`[0]*(~b.indexOf`x`?x**(b.split`^`[1]||1):1)+a,0)

Essayez-le en ligne!

Merci à @Arnauld

Étant donné que la meilleure solution JS jusqu'ici de @Arnauld (49 octets) a déjà été publiée et qu'elle utilise eval, j'ai décidé d'utiliser Regex et de réduire à la place de cela.

Assez long par rapport à sa pensée.

Explication:

A =>                            // lambda function accepting argument 1 
    x =>                        // argument number 2 (currying syntax used)
        A.match(                // this matches all instance of what comes next 
                                // and converts to array
       /[-]?(?:[x\d]+|\^?)+/g)  // regexp for -ve sign , variable number and ^ sign 
            .reduce((a, b) =>   // reduce the array to single (take 2 params a,b)
                b.split `x`     // split b at instances of `x` 
                        [0]     // and select the first instance 
                * (b.indexOf`x` // multiply that by value of index of x in b 
                    > 0 ?       // if it is greater than 0 then 
                x **            // multiplication will be with x raised to power
               (l = b.split `^` // set variable split b at every `x` 
                   [1]||1       // choose first index otherwise set to one
                )               // this is what x is raised to the power 
                : 1)            // in the case x is not present multiply by 1
                + a,            //  add value of `a` to that value 
        0)                      // in case no reduce is possible set value to 0

05AB1E , 16 19 octets

„*(I')J'xs:'^„**:.E

+3 octets comme correction de bogue pour une entrée négative x.

.E( Run as Batch code ) a été remplacé par Run as Pythoneval dans ce dernier commit de @Adnan , mais cette version n'est pas encore sur TIO. @ Mr.Xcoder l'a testé sur son local (dernière version) 05AB1E pour vérifier qu'il fonctionne.
Voir cette version sans .Evoir comment elle a converti la chaîne d'expression.

Explication:

„*I')J'xs:    # Replace all "x" with "*(n)" (where `n` is the input-integer)
              #  i.e. 5 and 3x^3-5x^2+2x-10 → 3*(5)^3-5*(5)^2-2*(5)-10
'^„**:        # Replace all "^" with "**"
              #  i.e. 3*(5)^3-5*(5)^2-2*(5)-10 → 3*(5)**3-5*(5)**2-2*(5)-10
.E            # Evaluate as Python-eval
              #  i.e. 3*(5)**3-5*(5)**2-2*(5)-10 → 250

Alternative 25 programme de 28 octets qui fonctionne sur la version actuelle de TIO:

„*(I')J'xs:'^„**:“…¢(“s')J.e

Essayez-le en ligne.

Explication:

„*(I')J'xs:'^„**:    # Same as explained above
“…¢(“                # Literal string "print("
     s               # Swap both
      ')             # Literal character ")"
        J            # Join everything together
                     #  i.e. 3*(5)**3-5*(5)**2-2*(5)-10 → print(3*(5)**3-5*(5)**2-2*(5)-10)
.e                   # Run as Python code
                     #  i.e. print(3*(5)**3-5*(5)**2-2*(5)-10) → 250

“…¢(“est la chaîne print(, car:

• “et “démarre et termine la chaîne compressée
• …¢est égal à 0426car il examine les index du fichier info.txt , où …a l'index 4 et l' ¢index 26.
• Cet index 0426est ensuite utilisé dans le fichier dictionnaire , où la ligne 427 (index 426) est le mot qu'il récupère, ce qui est printdans ce cas.
• Le (n'a pas d'index dans le fichier info.txt, il est donc interprété tel quel.

JavaScript (Node.js) , 143 octets

Je sais qu'il y a de meilleures réponses mais je voulais le faire sans utiliser eval

(_,x)=>_.match(/[+-]?(?:[a-z0-9.]+|\^-?)+/gi).reduce((a,b)=>~~(b.split('x')[0])*(b.indexOf('x')>0?Math.pow(x,(l=(b.split('^')[1]))?l:1):1)+a,0)

Essayez-le en ligne!

Physica , 35 octets

->e;x:Eval@Replace[e;"x";f"*({x})"]

Essayez-le en ligne!

Gelée , 21 octets

ṣ”^j⁾**ṣ”xjØ(j”*;Ʋ}ŒV

Essayez-le en ligne!

Java 8, 150 149 148 octets

n->s->new javax.script.ScriptEngineManager().getEngineByName("JS").eval(s.replace("x","*"+n).replaceAll((s="(\\-?\\d+)")+"\\^"+s,"Math.pow($1,$2)"))

Je ne sais pas s'il est possible d'avoir une fonction lambda currying qui lève une exception. Si c'est le cas, 1 octet peut être enregistré en changeant (s,n)->en n->s->. -1 octet merci à @ OlivierGrégoire de m'avoir montré comment faire cela.

Essayez-le en ligne.

Explication:

n->s->     // Method with integer and String parameters and Object return-type
  new javax.script.ScriptEngineManager().getEngineByName("JS")
            //  Use a JavaScript engine
   .eval(s  //  And eval the input
      .replace("x","*"+n)
            //   After all 'x' has been replaced with '*n'
            //   (where `n` is the input-integer)
      .replaceAll((s="(\\-?\\d+)")+"\\^"+s,"Math.pow($1,$2)"))
            //   And all `A^B` have have been replaced with `Math.pow(A,B)`
            //   (where both `A` and `B` are integers)

Malheureusement, l'évaluation JavaScript ne prend pas en charge **, je dois donc utiliser un remplacement plus long pour le convertir à la Math.powplace ..

TI-Basic, 6 octets

Prompt X:expr(Ans

L'expression est prise comme argument et X est entré pendant l'exécution. Alternativement 8 octets sans expr:

Prompt X,u:u

Ici, les deux arguments sont entrés au moment de l'exécution.

Octave , 47 38 37 octets

Économisé beaucoup d'octets en prenant la deuxième entrée comme une chaîne au lieu d'un nombre.

@(x,c)eval(strrep(x,'x',['*(',c,41]))

Essayez-le en ligne!

Explication:

Assez simple: remplacez xpar (c), où se ctrouve la deuxième entrée, et évaluez. Les parethèses sont nécessaires car à Octave -8^2 == -64.

Rubis , 43 octets

->s,x{eval s.gsub /[x^]/,?x=>"*x",?^=>"**"}

Essayez-le en ligne!

Perl 5 -pl , 35 octets

s/\^/**/g;$q=<>;s/x/*($q)/g;$_=eval

Essayez-le en ligne!

Rubis , 43 41 octets

->p,x{eval p.gsub('^','**').gsub'x','*x'}

Essayez-le en ligne!

Sauvegardé deux octets grâce à @ Mr.Xcoder

Puisqu'il n'y a pas encore de réponse Ruby, j'en ai ajouté une. Nvm il y en avait un qui utilisait une approche différente

Explication:

->p,x{                    # lambda function that takes two arguments p and x
    eval(                 # eval 
        p.gsub(           # replace all instance of 
            '^' , '**'    # `^` with `**` (use for raised to power of)
        )                 # end gsub
        .gsub(            # start another replace all
            'x' , '*x'    # replace all instances of `x` with `*x`
        )                 # end the replace function
    )                     # end eval function
}                         # end lambda function

Excel, 36 + 2 octets, non concurrent

L'évaluation d'un champ de texte en tant que formule n'est pas simple dans Excel. Il existe une =EVALUATE()fonction cachée , qui peut être appelée en définissant un nom.

Dans Excel 2007, Formules> Définir le nom. Définissez un nom appelé E, avec Fait référence à:

=EVALUATE(SUBSTITUTE(A1,"x","*"&B1))

Puis, avec l' entrée de la formule dans A1, la xvaleur en B1entrant =Edans les C1rendements résultat escompté.

Wolfram Language (Mathematica) , 19 octets

(x=#;ToExpression)&

Essayez-le en ligne!

Prenez entrée par curryfication: f[x][expr].