## How to simplify the basic mathematical expression?

Assuming that g is real, how can I simplify the following:
$$(2-2 ^ {- g}) + 2 ^ {- (g + 1)}$$

I know the simplification ends with:
$$2-2 ^ {- (g + 1)}$$

I just don't understand how to manipulate the equation.

## Explicit expression of sequence and rationality

We have : $$phi_ {1,1} = 1$$, and $$phi_ {a, b} = frac { phi_ {a-1, b-1}} {b (b-1)}$$ with $$a in ( mspace {-2 mu} (2, infty ( mspace {-2 mu} ($$ and $$b in ( mspace {-2 mu} (2, a) mspace {-2 mu})$$ and we have $$phi_ {n, 1} = sum_ {k = 2} ^ n (-1) ^ k phi_ {n, k}$$ with $$n in ( mspace {-2 mu} (2, infty ( mspace {-2 mu} ($$.

The question is: find the explicit expression of $$( phi_ {a, b})$$ and prove that all the elements of $$( phi_ {a, b})$$ is a rational number.

## order an expression ((3 + 5) * 2) in post-order and pre-order using stacks and tails in java

This is my second course on data structure and I am having trouble using stacks and queues, this time I am asked to order the expression in pre- order and post-order, as follows:
-expression, command in a queue
– Later, I insert parentheses and operators in the stack, and the numbers concatenate them into an empty string, terminating the process until the last parenthesis finds the opening parenthesis … example :
(a + b)
the following items are stored in the stack:
)
"+"
(
and the concatenated string would be:
ab
(this for the post order)

So far, I have only achieved the following goals:

``````public class OrdenaCad
{
public static void main(String() args)
{
Pilas objp = new Pilas();
Colas objc = new Colas();

for (int i = 0; i < cad.length(); i++)
{
}
}
}
``````

## FullSimplify expression with mathematical constants

L & # 39; writing:

``````{c1, c2, c3, c4, c5} = N({Tan(E), Sin(E), Tanh(E), E, Sinh(E)});

a = (c1 + c3) / 2;
b = Sqrt(c5^2 - (c2 - c4)^2) / 2;
c = 0;
d = (c2 + c4) / 2;
e = (c1 - c3) (c2 - c4) / (4 b);
f = c5 Sqrt(c5^2 - (c1 - c3)^2 - (c2 - c4)^2) / (4 b);
x = a + b Cos(t) + c Sin(t);
y = d + e Cos(t) + f Sin(t);

xmin = Minimize({x, 0 <= t <= 2π}, t)((1));
xmax = Maximize({x, 0 <= t <= 2π}, t)((1));
FullSimplify((xmin + xmax) / 2 == a)

ymin = Minimize({y, 0 <= t <= 2π}, t)((1));
ymax = Maximize({y, 0 <= t <= 2π}, t)((1));
FullSimplify((ymin + ymax) / 2 == d)
``````

we have:

True

True

this is what is desired. However, by making a simple change:

``````{c1, c2, c3, c4, c5} = {Tan(E), Sin(E), Tanh(E), E, Sinh(E)};
``````

we have:

True

...

that is to say, in the second case, there is no answer. How to solve this problem?

## co.combinatorics – Positive expression from Schur involving dashboards

Remember the expansion of the sum of the powers of the Schur functions,
$$s_ lambda = sum_ mu chi ^ { lambda} ( mu) frac {p_ mu} {z_ mu},$$
in terms of Sn character. These can be calculated
by the Murnaghan-Nakayama rule, declaring that
the characters are a sum signed on border tables:
$$chi ^ { lambda} ( mu) = sum_ {T in BST ( lambda, mu)} (-1) ^ {ht (T)}.$$

Now what happens if we consider rather "without cancellation"
expression (yes, the omission of $$z_ mu$$ is destined):
$$CF_ lambda: = sum_ mu | BST ( lambda, mu) | p_ mu.$$

Is the symmetric function $$CF_ lambda$$ also Schur-positive?
I have verified that this is the case for all $$| lambda | leq 8$$.

These are the data for all $$lambda$$ with at most size 4.

``````1->ss({1})
2->2 ss({2})
11->2 ss({2})
3->3 ss({3})+ss({2,1})+ss({1,1,1})
21->5 ss({3})+3 ss({2,1})+ss({1,1,1})
111->3 ss({3})+ss({2,1})+ss({1,1,1})
4->5 ss({4})+3 ss({2,2})+2 ss({3,1})+2 ss({2,1,1})+ss({1,1,1,1})
31->10 ss({4})+6 ss({2,2})+10 ss({3,1})+6 ss({2,1,1})+2 ss({1,1,1,1})
22->7 ss({4})+7 ss({2,2})+6 ss({3,1})+2 ss({2,1,1})+3 ss({1,1,1,1})
211->10 ss({4})+6 ss({2,2})+10 ss({3,1})+6 ss({2,1,1})+2 ss({1,1,1,1})
1111->5 ss({4})+3 ss({2,2})+2 ss({3,1})+2 ss({2,1,1})+ss({1,1,1,1})
``````

## SQL server – HIVE SQL [Error 10025]: Expression missing from the GROUP BY key

Here is my SQL statement:

my_table has more than 10 columns (for example, day, ip_address, user, request, etc.), including strings and numbers. I want to GROUP by & HAVE based on the column & # 39; ip_address & # 39;, if more than 20 records.

``````SELECT day, ip_address, user, request
FROM my_table
WHERE DAY = current_date()
HAVING count(client_ip)>20
``````

I have this error message

``````Error while compiling statement: FAILED: SemanticException (Error 10025): Expression not in GROUP BY key xxx
``````

But I have to keep all the columns.

## summons – an effective way to evaluate this expression

Is there an effective way to assess something like this?

``````Np=10;
xx = 0.;
Do(
Do(
Do(
Do(
Do(
Do(
If((1. ix - 1. jx)^2 + (1. iy - 1. jy)^2 + (1. iz - 1. jz)^2 ==
0., xx += 0.,
xx += 1./(Sqrt((1. ix - 1. jx)^2 + (1. iy -
1. jy)^2 + (1. iz - 1. jz)^2))^3
, {jz, Np}),
{iz, Np}),
{jy, Np}),
{iy, Np}),
{jx, Np}),
{ix, Np})
``````

The problem is not the complexity, but the fact that there are six independent variables and the test in it `If`. You can imagine what happens if `Np` is increased. The time it takes to assess this increases a little.

I tried to evaluate the expression which can become null separately and I put the results in six nested ways `Table`. The plan was then `Flatten` the `Table` and remove the values ​​equal to 0, then summate with something like `Total` on the inverse values. But that way, I come across a memory problem, because if I increase the Np, this whole huge array must be written in memory.

The question is therefore: is there a way to effectively evaluate the sum in my example, for Np = 100?

## finite automata – Converting an NFA with 2 initial states into a regular expression using state elimination

The task is to determine the language accepted by the following NFA:

My approach to these problems is to convert the NFA into a regular expression and (for the algorithm):

If the initial state has incoming transitions: create a new starting state with an epsilon transition

If there are more than 1 final states OR the final state has outgoing edges: create a new final state with 1 (or more) epsilon transition (s).

In the end, only 2 states remain.

I can't find any solution related to the approach mentioned above in the case of 2 starting states. Any contribution on this situation would be useful.

Thank you!

## optimization – Expression of closed form for a maximization problem with a binary decision variable

I have a maximization problem as follows:

$$max _ { mathbf {p}} w text {ln} Bigg ( sum_ {i = 1} ^ I p_ia_i Bigg) – sum_ {i = 1} ^ {I} p_id_i,$$

or $$p_i in {0,1 }$$ is a binary variable. I need to find optimal $$p ^ * _ i$$, or

$$mathbf {p} ^ * = arg max _ { mathbf {p}} w text {ln} Bigg ( sum_ {i = 1} ^ I p_ia_i Bigg) – sum_ {i = 1} ^ {I} p_id_i$$.

Is there a way to get the closed form of $$p ^ * _ i$$ in terms of $$w$$, $$a_i$$, and $$d_i$$?

## regular expression – Can we use the regular expression in the robots.txt file to block URLs?

Regular expressions are not valid in robots.txt, but Google, Bing, and some other bots recognize certain pattern matches.

Say if you want to block all URLs that have a `example` anywhere in the URL you can use a generic entry *

``````User-agent: *
Disallow: /*example
``````

You can also use the dollar sign \$ to specify that URLs should end this way. So if you wanted to block all URLs ending in `example`, but not URLs that had a`example` elsewhere in the URL you could use:

``````User-agent: *
Disallow: /*example\$
``````

More detailed information on Google can be found here: Specifications Robots.txt, Bing here: How to create a Robots.txt file and there is an interactive guide to Moz here