The problem
Write a program that may do some algebra. Write a operate increase that takes in an expression with a single, one character variable, and expands it. The expression is within the kind (ax+b)^n the place a and b are integers which can be optimistic or damaging, x is any single character variable, and n is a pure quantity. If a = 1, no coefficient will likely be positioned in entrance of the variable. If a = -1, a “-” will likely be positioned in entrance of the variable.
The expanded kind needs to be returned as a string within the kind ax^b+cx^d+ex^f... the place a, c, and e are the coefficients of the time period, x is the unique one character variable that was handed within the unique expression and b, d, and f, are the powers that x is being raised to in every time period and are in reducing order. If the coefficient of a time period is zero, the time period shouldn’t be included. If the coefficient of a time period is one, the coefficient shouldn’t be included. If the coefficient of a time period is -1, solely the “-” needs to be included. If the ability of the time period is 0, solely the coefficient needs to be included. If the ability of the time period is 1, the caret and energy needs to be excluded.
Examples
Resolution.increase("(x+1)^2"); // returns "x^2+2x+1"
Resolution.increase("(p-1)^3"); // returns "p^3-3p^2+3p-1"
Resolution.increase("(2f+4)^6"); // returns "64f^6+768f^5+3840f^4+10240f^3+15360f^2+12288f+4096"
Resolution.increase("(-2a-4)^0"); // returns "1"
Resolution.increase("(-12t+43)^2"); // returns "144t^2-1032t+1849"
Resolution.increase("(r+0)^203"); // returns "r^203"
Resolution.increase("(-x-1)^2"); // returns "x^2+2x+1"
The answer in Java code
Choice 1:
import java.util.regex.*;
import java.util.*;
import java.lang.*;
public class Resolution {
public static String increase(String expr) {
Sample sample = Sample.compile("((-?d*)(.)([-+]d+))^(d+)");
Matcher matcher = sample.matcher(expr);
matcher.discover();
ultimate String _a = matcher.group(1);
ultimate int a = _a.isEmpty() ? 1 : _a.equals("-") ? -1 : Integer.parseInt(_a);
ultimate String x = matcher.group(2);
ultimate int b = Integer.parseInt(matcher.group(3).change("+", ""));
ultimate int n = Integer.parseInt(matcher.group(4).change("+", ""));
double f = Math.pow((double)a, n);
if (n == 0) return "1";
if (a == 0) return String.format("%d", (int)Math.pow((double)b, n));
if (b == 0) return String.format("%dpercentspercents", (int)f, x, (n > 1) ? String.format("^%d", n) : "");
ultimate StringBuilder outcome = new StringBuilder();
for (int i = 0; i <= n; i++)
return outcome.toString();
}
}
Choice 2:
import java.util.*;
import java.util.regex.*;
import java.util.stream.*;
import java.math.BigInteger;
public class Resolution {
ultimate static non-public Sample P_POLY = Sample.compile("((-?d*)(w+)+?(-?d+))^(d+)"),
CLEANER = Sample.compile("b1(?=[a-z])|^1b|+$|+(?=-)");
public static String increase(String expr) {
Matcher m = P_POLY.matcher(expr);
m.discover();
int i = 1;
String as = m.group(i++),
xs = m.group(i++),
bs = m.group(i++),
es = m.group(i++);
if ("0".equals(es)) return "1";
int e = Integer.parseInt(es);
BigInteger a = new BigInteger( "-".equals(as) ? "-1" : as.isEmpty() ? "1" : as),
b = new BigInteger(bs);
Listing<BigInteger> poly = new ArrayList<>(Arrays.asList(a,b)),
tmp = null;
for (i=0 ; i<e-1 ; i++) {
poly.add(BigInteger.ZERO);
tmp = poly.stream().gather(Collectors.toList());
int s = poly.dimension();
for (int j=0 ; j<s ; j++) { tmp.set(j, a.multiply(poly.get(j))
.add( b.multiply(poly.get((s+j-1) % s))) ); }
poly = tmp;
}
StringBuilder sb = new StringBuilder();
i = -1;
for (BigInteger coef: poly) { i++;
if (coef.equals(BigInteger.ZERO)) proceed;
if (i==e) sb.append(""+coef);
else sb.append(String.format("%dpercents^%d", coef, xs, e-i));
sb.append("+");
}
return CLEANER.matcher(sb.toString())
.replaceAll("");
}
}
Choice 3:
public class Resolution {
public static String increase(String expr) {
String[] vals = extractValues(expr).cut up(":");
if(Integer.parseInt(vals[0]) == 0) return "1";
if(Integer.parseInt(vals[0]) == 1) return refine(vals[1] + "+" + vals[2]);
return higherOrder(vals[1], Integer.parseInt(vals[2]), Integer.parseInt(vals[0]));
}
non-public static String extractValues(String expr){
String format = "((-?[a-z0-9]+)+?(-?[a-z0-9]+))^([0-9]+)";
return expr.replaceAll(format,"$3") + ":"
+ expr.replaceAll(format,"$1") + ":"
+ expr.replaceAll(format,"$2");
}
non-public static String refine(String expr){
expr = expr.replaceAll("-1([a-z])", "-$1");
return expr.change("+-", "-");
}
non-public static String higherOrder(String s1, int s2, int pow){
String res = java.util.stream.IntStream
.rangeClosed(0, pow)
.mapToObj(okay -> binoThm(pow, okay, s1, s2))
.filter(s -> s.size() > 0)
.gather(java.util.stream.Collectors.becoming a member of("+"));
return refine(res);
}
non-public static String binoThm(int n, int r, String s1, int n2){
lengthy nCr = nCr(n, r);
int n1 = getNum(s1);
s1 = s1.replaceAll("[0-9-]","");
lengthy coeff = (lengthy)(nCr * Math.pow(n1, n - r) * Math.pow(n2, r));
if(coeff == 0) return "";
String var = (n - r > 0 ?( s1 + ((n - r > 1) ? ("^" + (n - r)) : "")) : "");
return ((coeff == 1 && n - r > 0)? "" : coeff) + "" + var;
}
non-public static int getNum(String s){
attempt{
String val = s.replaceAll("[a-z]","");
if(val.equals("-")) return -1;
return (Integer.parseInt(val));
}catch(Exception e){
}
return 1;
}
non-public static lengthy nCr(int n, int r){
lengthy p = 1, okay = 1;
if (n - r < r)
r = n - r;
if (r != 0) {
whereas (r > 0) {
p *= n;
okay *= r;
lengthy m = gcd(p, okay);
p /= m;
okay /= m;
n--;
r--;
}
}
return p;
}
non-public static lengthy gcd(lengthy a, lengthy b) {
return b == 0 ? a : gcd(b, apercentb);
}
}
Take a look at instances to validate our resolution
import org.junit.Take a look at;
import static org.junit.Assert.assertEquals;
public class ExampleTest {
@Take a look at
public void testBPositive() {
assertEquals("1", Resolution.increase("(x+1)^0"));
assertEquals("x+1", Resolution.increase("(x+1)^1"));
assertEquals("x^2+2x+1", Resolution.increase("(x+1)^2"));
}
@Take a look at
public void testBNegative() {
assertEquals("1", Resolution.increase("(x-1)^0"));
assertEquals("x-1", Resolution.increase("(x-1)^1"));
assertEquals("x^2-2x+1", Resolution.increase("(x-1)^2"));
}
@Take a look at
public void testAPositive() {
assertEquals("625m^4+1500m^3+1350m^2+540m+81", Resolution.increase("(5m+3)^4"));
assertEquals("8x^3-36x^2+54x-27", Resolution.increase("(2x-3)^3"));
assertEquals("1", Resolution.increase("(7x-7)^0"));
}
@Take a look at
public void testANegative() {
assertEquals("625m^4-1500m^3+1350m^2-540m+81", Resolution.increase("(-5m+3)^4"));
assertEquals("-8k^3-36k^2-54k-27", Resolution.increase("(-2k-3)^3"));
assertEquals("1", Resolution.increase("(-7x-7)^0"));
}
}