Un polynôme est divisible par un facteur (x-n)si f(n)=0pour une fonction f. Votre travail: déterminer si une fonction polynomiale f(x)est divisible par (x-n).

L'entrée

L'entrée est sous la forme de (x-n), (Polynomial). Rappelez-vous, si n est négatif, (x-n)sera sous la forme d'entrée de(x+n) . Pour le polynôme, tous les exposants seront mis en tant que ^. Les coefficients seront écrits à côté de la variable x. Un exemple de polynôme pourrait être 2x^2 + x^1. Il n'y aura aucun espace entre rien. Le terme xsera entré comme x^1. Alors , à quoi ressemblerait « normalement » comme (x - 1)sera (x^1-1). Les coefficients et les puissances seront toujours des entiers. Le coefficient un sera implicite s'il est juste x. C'est-à-dire, xpeut être interprété comme1x

Le résultat

Une valeur booléenne. Truthy ou Falsey.

Merci à @AlexA. Pour m'avoir aidé à clarifier cela!

Exemples

Input:(x^1-1),(x^1-1)
Output: True

Input: (x^1+2),(2x^2+4x^1+2)
Output: False

Input: (x^1+7),(x^2-49)
Output: True

Règles

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

Malheureusement, je ne sais pas comment implémenter le leaderboard d'extraits. Si quelqu'un sait comment, n'hésitez pas à modifier le message.

Pyth - 39 octets

Il s'agit d'une combinaison monstrueuse de regexp et eval. J'aime l'approche, mais j'essaierai d'améliorer la mise en œuvre.

Il utilise le théorème des restes polynomiaux .

K_sPe:z"-|\+"3!v.ssXPtw,\^\x,"**""*K"\*

Ne fonctionne pas en ligne en raison de l'utilisation de l'eval.

Casio Basic, 19 octets

judge(mod(b,a)=0

En fait, le fx-CP400 peut faire modsur les expressions algébriques!

Le polynôme et le facteur doivent être saisis comme expressions. 16 octets pour le code, 3 octets pour entrer a,bdans la zone de valeur du paramètre.

MATLAB, 103 99 97 95 93 octets

J'essaie différentes choses, et j'ai réussi à économiser quelques octets:

eval([regexprep(input(''),{'.+?1(.+)\),','(\d)x'},{'x=str2num(''$1'');disp(~','$1\*x'}) 41]);

Si je peux encore réduire cela, je posterai une explication.

Ancien code une explication

t=sscanf(input(''),'(x^1%d),%s')';x=-t(1);disp(~eval(regexprep([t(2:end) ''],'(\d)x','$1\*x')))

Cela fonctionne également avec Octave . Vous pouvez l' essayer en ligne . J'ai enregistré le programme en tant que script nommé isFactor.m, vous pouvez donc simplement entrer isFactorà l'invite. [Remarque: dans Octave crache un avertissement lors de l'exécution - MATLAB ne génère pas cela].

L'entrée doit être au format '(x^1+7),(x^2-49)'selon la question. Les guillemets sont ajoutés pour que MATLAB / Octave sache qu'il s'agit d'une chaîne.

La sortie est soit a 0soit a 1selon qu'elle est vraie ou fausse.

Ainsi, le code fonctionne comme suit. Nous demandons d'abord une entrée, puis nous l'analysons. La chaîne d'analyse extrait le numéro signé après le premier (x^1de la chaîne - c'est notre valeur de n. Ensuite, il continue d'extraire la chaîne ( %s) après ),l'entrée dans - c'est notre expression.

t=sscanf(input(''),'(x^1%d),%s')';

Ensuite, nous extrayons la valeur de net la xmettons égale à elle - nous allons évaluer si l'expression est égale à zéro quand n==x, c'est pourquoi nous stockons la valeur dans x. Nous annulons également le nombre extrait, en raison du signe moins lors de l'analyse.

x=-t(1);

Nous afficherons ensuite la sortie qui est un booléen

disp(

La sortie est fondamentalement la négation logique de notre équation évaluée. Si f(x)est zéro, cela retournera 1, sinon il en résultera zéro.

     ~eval(

Nous évaluons l'expression d'entrée, mais pour ce faire, nous devons la reformater légèrement afin que MATLAB puisse comprendre. Lorsque nous lisons la chaîne, il s'agit en fait d'un tableau de doubletype, nous devons donc le convertir en un tableau de caractères. Avant la conversion, nous nous débarrassons également du premier élément car c'est ce que nous avons utilisé n. Nous devons ensuite remplacer toute occurrence xqui est précédée d'un nombre (par exemple 4x) par la même chose mais avec un *signe multiplication ( ) entre afin que MATLAB puisse le calculer.

           regexprep(char([t(2:end) ''],'(\d)x','$1\*x')
     )
)

VBScript, 118 116 octets

a=inputbox(""):for i=0 to 9:a=replace(a,i&"x",i&"*x"):next:b=split(a,","):x=-eval(b(0)):msgbox not cbool(eval(b(1)))

Puisque nous savons que la première partie de l'entrée est un polynôme linéaire, nous n'avons qu'à vérifier si sa racine correspond à celle du deuxième polynôme; et nous devons préparer le terme evalen l'insérant *au besoin.

Axiom 77 180 Octets

f(a:UP(x,INT),b:UP(x,INT)):Boolean==(ground?(a)or ground?(b)=>false;p:=b;r:=a;if degree(a::POLY INT,x)>degree(b::POLY INT,x)then(p:=a;r:=b);(p rem r)$UP(x,FRAC INT)~=0=>false;true)

la solution précédente

v(a,b)==(ground?(a) or ground?(b) or (b rem a)$UP(x,FRAC INT)~=0=>false;true)

était faux car il suppose degré (b)> = degré (a) un bug que j'ai écrit ... test et résultats

(3) -> f(x^1-1,x^1-1)
   (3)  true
                                                            Type: Boolean
(4) -> f(x^1+1,2*x^2+4*x^1+2)
   (4)  true
                                                            Type: Boolean
(5) -> f(x^1+2,2*x^2+4*x^1+2)
   (5)  false
                                                            Type: Boolean
(6) -> f(x^1+7,x^2-49)
   (6)  true
                                                            Type: Boolean
(7) -> f(1, 1)
   (7)  false
                                                            Type: Boolean
(8) -> f(1, x^2+1)
   (8)  false
                                                            Type: Boolean
(9) -> f(x^8-1, x^2-1)
   (9)  true