source : yahoo.com

## Which expression is equivalent to (f + g)(4)?

f(x) = something with “x”

g(x) = something else with “x” as the variable.

Think of a function as a recipe.

“f” is the name of one recipe. “x” is the secret ingredient and everything after the equal sign is the recipe (the instructions on what to do with the secret ingredient, once you are told what it is).

f(4) would simply mean:

Use recipe “f” and secret ingredient “4” (you use 4 wherever you see “x” in the instructions).

(f + g)(x)

would itself be a function (a recipe) created by adding together the instructions from “f” and the instructions from “g”.

Once you have done that, then apply this combined recipe to secret ingredient “4” to get

(f + g)(4)

Example:

f(x) = 4x – 2

g(x) = 3x + 7

f(x) + g(x) = (4x – 2) + (3x + 7)

combining:

(f + g)(x) = 7x + 5

In this example, if you are asked to find (f + g)(4), you would use this combined recipe (the function called “(f+g)” ) and use 4 wherever you see “x”

(f + g)(4) = 7(4) + 5 = 28 + 5 = 33

As it turns out, you get the same result if you do each function separately, then add the results:

f(4) = 14

g(4) = 19

f(4) + g(4) = 14 + 19 = 33

If f (x) = 4 – x2 and g (x) = 6x, which expression is – If f (x) = 4 – x2 and g (x) = 6x, which expression is equivalent to (g – 1) (3) ? O9-3 – (4 + 3) 2 6 – 3 – (4 – 32) 6 (3) – 4 + 32 6 (3) – 4-32 ОО. Find an answer to your question "If f (x) = 4 – x2 and g (x) = 6x, which expression is equivalent to (g – 1) (3) ?O9-3 – (4 + 3) 2 6 – 3 – (4 – 32) 6 (3) – 4 + 32 6 (3) -" in 📘 Mathematics if you're in doubt about the correctness ofQuestion: Which expressions are equivalent to 2(4f + 2g) Choose 3 answers: 8f +2g 2f(4+2g) 8f +4g 4(2f +g) 4f+4f +4g. Sue makes 50 litres of green paint by mixing litres of yellow paint and litres of blue paint in the ratio 1:4.The expression is equivalent to f (4) and g (4) means that we should find the value of our function when x equals 4. (f+g) (4) means we should find the value of our function as sum, when x equals 4.

Which expressions are equivalent to 2(4f + 2g) Choose 3 – 19. Iffx) = log 4x and g(x) = x2 – 2, which of these expressions is equivalent to f(g(4))? log 4 x log 14 b. log? 16-2 c. log? 14 d. log 4 + log 14 the domain of y=f(xaly 19.Equivalent expressions Calculator online with solution and steps. Detailed step by step solutions to your Equivalent expressions problems online with our math solver and calculator. Solved exercises of Equivalent expressions.8371 views around the world You can reuse this answer Creative Commons License

Which expression is equivalent to (f + g)(4)? f(4) + g(4 – 3 The expression 2− x −1 x +2 is equivalent to 1) 1− 4) f(x) ÷g(x) 24 The scores on a mathematics college-entry exam are normally distributed with a mean of 68 and standard deviation 7.2. Students scoring higher than one standard deviation above the mean willAnswer to Which expression is NOT equivalent to ?F. G. H. J. . Prentice Hall Mathematics, Algebra 2 (0th Edition) Edit edition. Problem 89E from Chapter 7.4: Which expression is NOT equivalent to ?F. G. H. J.Which expression is equivalent to the expression above for all values of q where the expressions is defined? answer choices . Tags: Question 29 . SURVEY . 300 seconds The graphs of linear functions f and g are shown on the grid. Which function is best represented by the graph of g? answer choices . g(x) = f(x) – 4. g(x) = 1 / 3 f(x)

**# 4 Mathematical Induction prove 1/(1×2)+1/(2X3)+…+1/n(n+1)=n/(n+1) mathgotserved** – .

**How to #12 Proof by induction 1^3+2^3+3^3+…+n^3= (n(n+1)/2)^2 n^2(n+1)^2/4 prove mathgotserved** – .

**Evaluation of Prefix and Postfix expressions using stack** – In our previous lesson, we saw what

prefix and postfix expressions are but we did not discuss how we can

evaluate these expressions.

In this lesson we'll see how we can

evaluate prefix and postfix expressions. Algorithms to evaluate prefix and

postfix expressions are similar but I'm going to talk about postfix

evaluation first because its easier to understand and

implement and then I'll talk about evaluation of

prefix. Okay so let's get started. I have written an expression in infix form

here and I first want to convert this to postfix form. As we know in infix form operator is

written in between operands and we want to convert to postfix in

which operator is written after operands. We have already seen how we can do

this in our previous lesson. We need to go step by step just the way we would go in evaluation of infix. We need to go in

order of precedence and in each step we need to identify operands of an operator and we need to

bring the operator in front of the operands. What we can

actually do is we can first resolve operator precedence and put

parenthesis at appropriate places. In this expression

we will first do this multiplication this first

multiplication then we'll do this second multiplication then we will perform this addition and

finally the subtraction. Okay now we will go one

operator at a time, operands for this multiplication

operator are 'A' and 'B'. So this A*B will become AB*. Now next we would need to look at this

multiplication this will transform to cd* and now we can do the change for this addition the two operands are these two expressions in postfix, so I'm placing the plus

operator after these two expressions. Finally for this last operator the operands are this complex expression

and this variable 'e'. So this is how we will look like after the transformation. Finally when we

are done with all the operators we can get rid of all the paranthesis. They're not needed in postfix expression. This is how you can do the conversion

manualy. We will discuss efficient ways of doing this programitically in later lessons. We will discuss algorithms to convert infix to prefix or postfix in later lessons. In this lesson we're

only going to look at algorithms to evaluate prefix and

postfix expressions. Okay so we have this postfix

expression here and we want to evaluate this expression,

let's say for these values of variables a,b,c,d and e. So we have this expression in

terms of values to evaluate. I'll first quickly tell you how you can

evaluate a postfix expression manually. What you need to do is you need to scan

the expression from left to right and find the first occurrence of an

operator like here, multiplication is the first operator.

In postfix expression operands of an operator will always

lie to its left. For the first operator, the preceding two

entities will always be operands. You need to look for the first

occurrence of this pattern operand, operand, operator in the expression

and now you can apply the operator on these two operands and reduced expression. So this is

what I'm getting after evaluating 23*. Now we need to repeat this

process till we are done with all the operators. Once again we need to

scan the expression from left to right and look for the first operator, if the

expression is correct it will be preceeded by two values. So basically we need to look for first

occurrence of this pattern operand, operand, operator. So now we can reduce this. we have 6 and then we have 5*4 20. We are using space as delimeter here, there should be some space in between two operands. Okay so this is

what I have now. Once again I'll look for the first

occurrence of operand, operand and operator. We will go on like this till we are done with all the operators. When I am saying we need to look for first

occurrence of this pattern operand, operand and operator, what I mean by operand here is a value and

not a complex expression itself. The first

operator will always be preceded by two values and if you will give this some thought you will

be able to understand why. If you can see in this expression we are

applying the operators in the same order in which we have them while

parsing from left to right. So first we're applying this leftmost

multiplication on 2 and 3 then we are applying the next

multiplication on 5 and 4 then we're performing the addition and then finally we are performing the

subtraction and whenever we are performing an operation, we're picking the last two operands proceeding the operator in the

expression. So if we have to do this programitically,

if we have to evaluate a postfix expression given to us in a string like this and let's say operands and operators are separated by space we can have some

other delimiter like comma also to separate operands

and operator. Now what we can do is we can parse the

string from left to right. In each step in this parsing, in each

step in the scanning process, we can get a token that will either be an

operator or an operand. What we can do is as we parse from left to right, we can keep track

of all the operands seen so far and I'll come back to how it

will help us. So I'm keeping all the operands so seen so

far in a list. The first entity that we have here is 2 which is an operand so it will go to the

list, next we have 3 which once again is operand so it will go into the list next we have this multiplication

operator. Now this multiplication should be applied to last two operands preceding it last

two operands to the left of it because we already have the elements stored in this list. All we need to do is we need to pick the

last two from this list and perform the operation. It should be 2*3 and with this multiplication we have reduced expression this 23* has now become 6 it has become an operand that can be used by an operator later. We are at this stage right now that I'm

showing in the right. I'll continue the scanning. Next we have an operand, will push this number 5 on to the

list. Next we have 4 which once again will

come to the list and now we have the multiplication operator and it should be applied to the last two

operands in the reduced expression and we should put the result back into the list. This is the stage

where we are right now. So this list actually is storing all the

operands in the reduced expression preceeding the position at which we are during passing. Now for this edition we should take out

the last two elements from the list and then we should put the result back,

next we have an operand we are at this stage right now. Next we have

an operator this subtraction. We will perform this

subtraction and put the result back. Finally when I'm done

scanning the whole expression I'll have only one element left in the list and this will be my final answer this

will be my final result. This is an efficient algorithm. We

are doing only one pass on the string representing the expression and we have our result. The list that we are using here if you could notice is being used in a

special way we are inserting operands one at a time

from one side and then to perform an operation we are

taking out operand from the same side. Whatever is coming in last is getting

out first. This whole thing that we're doing here

with the list can be done efficiently with a stack, which is nothing but a

special kind of list in which elements are inserted and removed from the same side in which

whatever gets in last comes out first. It's called Last In First

Out(LIFO) structure. Let's do this evaluation again. I have drawn

logical representation of stack here, and this time I'm going to use this stack.

I'll also write pseudo code for this algorithm. I'm going to write a function named evaluate postfix that will take a string

as argument. Let's name this string expression exp for expression. In my function here, i'll first create a stack. Now for the sake of simplicity, let's assume that each operand or operator

in the expression will be of only one character. So to get a token or operator,

We can simply run a loop from zero till length of expression -1. So exp[i] will be my operand or operator. If

expression 'i' is operand I should put, push it onto the stack

else if exp[i] is operator we should do two pop operations in the

stack store the value of the operands in some variable. I'm using variable names op1 and op2. Let's say this pop function will remove

an element from top of stack s and also return this element. Once we have the two operands we can perform the operation, I'm using this

variable to store the output. Let's say this function will perform the operation. Now the result should be pushed back onto the stack. If

I have to run through this expression with whatever code I have right now,

then first entity is 2 which is operand so it should be pushed onto the stack.

Next we have 3, once again this will go to the stack.

Next we have this multiplication operator. So we will come to this else if part of

the code. I'll make first pop and I'll store 3 in this variable op1. Well actually this is the second operand,

so I should say this one is op2 and next one will be op1. Once I have popped these two elements I can perform the

operation. As you can see I'm doing the same stuff that I was doing with the list, the only thing is that I'm showing

things vertically. Stack is being shown as a vertical list. I'm

inserting or taking out from the top. Now I'll push the result back onto the

stack. Now we will move to the next entity

which is operand it will go onto the stack. Next 4 will

also go onto the stack and now we have this multiplication, so we

will perform two pop operations. After this operation

is performed result will be pushed back. Next we have

addition. So we will go on like this. We have 26

pushed onto the stack now. Now it's 9 which will go in and

finally we have this subtraction 26-9, 17 will be pushed onto the stack. At this stage we will be done with the loop we are done with all the tokens, all the

operands and operators. The top of stack can be returned as

final result. At this stage we will have only one

element in the stack and this element will be my final result.

You will have to take care of some parsing logic in actual implementation.

Operand can be a number of multiple digits and then we will have delimiter like

space or comma so you'll have to take care of that.

Parsing operand or operator will be some task. If you want to see my implementation you

can check the description of this video for a link. Okay so this was postfix evaluation.

Let's now quickly see how we can do prefix evaluation. Once again I have written this expression in

infix form and I'll first convert it to prefix. We will go in order of precedence. I first

put this paranthesis this 2 * 3 will become *23, this 5 * 4 will become *54 and now we will pick this plus(+) operator whose operands are these two prefix expressions. Finally for the subtraction operator this is

the first operand and this is the second operand. In the last step we can get rid of all the

parenthesis. So this is what I have finally. Let's now

see how we can evaluate a prefix expression like this. We will do it just like postfix this time all we need to do is we need

to scan from right, so we will go from right to left. Once again we will people use a stack if it's an

operand we can push it onto the stack. So here for this example 9 will go onto the stack and now we will go to the next entity in the left, it's 4. Once again we have an operand. It will go onto the stack. Now we have 5. 5 will also be pushed onto the stack and

now we have this multiplication operator. At this stage we need to pop two elements from the stack. This time the first element popped will be the first operand. In postfix the first element popped was

the second operand. This time the second element popped will

be the second operand. For this multiplication, first operand is 5 and second operand is 4. This order is really important for multipication the order doesn't matter but for say division or subtraction this will matter. Result 20 will be pushed onto the stack and we

will keep moving left. Now we have 3 and 2 both will go onto the stack and now we have this multiplication operation. 3 and 2 will be popped and their product 6 will be pushed. Now we have this addition, the two

elements at top are 20 and 6 they will be popped and their sum 26 will be pushed. Finally we have to subtraction. 26 and 9 will be popped out and 17 will be

pushed and finally this is my answer. Prefix evaluation can be performed in couple of other ways also but this

is easiest and most straightforward. Okay so this was prefix

and postfix evaluation using Stack. In coming lessons, we will see efficient algorithms to convert infix to prefix or postfix. This is it

for this lesson. Thanks for Watching! .