Un polinomio è divisibile per un fattore (x-n)se f(n)=0per una funzione f. Il tuo lavoro: determinare se una funzione polinomiale f(x)è divisibile per (x-n).

L'input

L'input è in forma di (x-n), (Polynomial). Ricorda, se n è negativo, (x-n)sarà nella forma di input di(x+n) . Per il polinomio, tutti gli esponenti verranno inseriti come ^. I coefficienti verranno scritti accanto alla variabile x. Un polinomio di esempio potrebbe essere 2x^2 + x^1. Non ci saranno spazi tra nulla. Il termine xverrà inserito come x^1. Così che cosa sarebbe "normalmente" apparire come (x - 1)sarà (x^1-1). I coefficienti e i poteri saranno sempre numeri interi. Il coefficiente uno sarà implicito se è giusto x. Cioè, xpuò essere interpretato come1x

Il risultato

Un valore booleano. Verità o Falsey.

Grazie a @AlexA. Per avermi aiutato a chiarire questo!

Esempi

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

Regole

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

Sfortunatamente, non so come implementare la classifica dello snippet. Se qualcuno sa come, sentiti libero di modificare il post.

Pyth - 39 byte

Questa è una mostruosa combinazione di regexp ed eval. Mi piace l'approccio, ma proverò a migliorare l'implementazione.

Usa il teorema del residuo polinomiale .

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

Non funziona online a causa dell'uso eval.

Casio Basic, 19 byte

judge(mod(b,a)=0

A quanto pare, il FX-CP400 può fare modsu espressioni algebriche!

Polinomio e fattore devono essere inseriti come espressioni. 16 byte per il codice, 3 byte da inserire a,bnella casella del valore del parametro.

MATLAB, 103 99 97 95 93 byte

Sto provando alcune cose diverse e ho fatto in modo che funzioni per salvare un paio di byte:

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

Se riesco a ridurlo ulteriormente, posterò una spiegazione.

Il vecchio codice è una spiegazione

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

Questo funziona anche con Octave . Puoi provarlo online . Ho salvato il programma come uno script chiamato isFactor.m, quindi puoi semplicemente entrare isFactoral prompt. [Nota: in Octave emette un avviso durante l'esecuzione - MATLAB non lo genera].

L'input deve essere nel formato '(x^1+7),(x^2-49)'secondo la domanda. Le virgolette vengono aggiunte in modo che MATLAB / Octave sappia che è una stringa.

L'output è a 0o a a 1seconda che sia vero o falso.

Quindi, il codice funziona come segue. Innanzitutto chiediamo un input, quindi lo analizziamo. La stringa di analisi estrae il numero con segno dopo il primo (x^1nella stringa - questo è il nostro valore di n. Quindi continua a estrarre la stringa ( %s) dopo ),l'input - questa è la nostra espressione.

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

Quindi, estraiamo il valore di ne impostiamo xuguale ad esso - valuteremo se l'espressione è uguale a zero quando n==x, quindi è per questo che memorizziamo il valore in x. Inoltre neghiamo il numero estratto, a causa del segno meno durante l'analisi.

x=-t(1);

Visualizzeremo quindi l'output che è un valore booleano

disp(

L'output è fondamentalmente la negazione logica della nostra equazione valutata. Se f(x)è zero, questo restituirà 1, altrimenti si tradurrà in zero.

     ~eval(

Stiamo valutando l'espressione di input, ma per fare questo, dobbiamo riformattarla leggermente in modo che MATLAB possa capire. Quando leggiamo la stringa, in realtà è una matrice di doubletipo, quindi dobbiamo convertirla in una matrice di caratteri. Prima della conversione ci liberiamo anche del primo elemento poiché è quello che abbiamo usato n. Dobbiamo quindi sostituire qualsiasi occorrenza di xcui è preceduto da un numero (ad esempio 4x) con la stessa cosa ma con un *segno di moltiplicazione ( ) tra i due in modo che MATLAB possa calcolarlo.

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

VBScript, 118 116 byte

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

Poiché sappiamo che la prima parte dell'input è un polinomio lineare, dobbiamo solo verificare se la sua radice corrisponde a quella del secondo polinomio; e dobbiamo preparare il termine evalinserendolo *come necessario.

Axiom 77 180 byte

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 soluzione precedente

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

era sbagliato perché presuppone grado (b)> = grado (a) un bug che ho scritto ... test e risultati

(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