86:I[871206,["$1","$2","$3","$4","$5","$6","$7","$8","$9","$a","$b","$c","$d","$e","$f","$10","$11","$12","$13","$14","$15"],"IconMark"] 87:I[196793,["$1","$2","$3","$4","$5","$6","$7","$8","$9","$a","$b","$c","$d","$e","$f","$10","$11","$12","$13","$14","$15","$3b","$3c","$3d","$3e","$3f","$40","$41","$42","$43","$44","$45","$46","$47","$48","$49","$4a","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"Gingerbread"] 89:"RecordResourceResume" 8a:I[647935,["$1","$2","$3","$4","$5","$6","$7","$8","$9","$a","$b","$c","$d","$e","$f","$10","$11","$12","$13","$14","$15","$3b","$3c","$3d","$3e","$3f","$40","$41","$42","$43","$44","$45","$46","$47","$48","$49","$4a","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$89"] 8b:I[473028,["$1","$2","$3","$4","$5","$6","$7","$8","$9","$a","$b","$c","$d","$e","$f","$10","$11","$12","$13","$14","$15","$3b","$3c","$3d","$3e","$3f","$40","$41","$42","$43","$44","$45","$46","$47","$48","$49","$4a","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"RecordTopicView"] 8c:"FlashcardAccessBranch" 8d:I[830476,["$1","$2","$3","$4","$5","$6","$7","$8","$9","$a","$b","$c","$d","$e","$f","$10","$11","$12","$13","$14","$15","$3b","$3c","$3d","$3e","$3f","$40","$41","$42","$43","$44","$45","$46","$47","$48","$49","$4a","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$8c"] 8e:"TopicFlashcardRunner" 8f:I[315438,["$1","$2","$3","$4","$5","$6","$7","$8","$9","$a","$b","$c","$d","$e","$f","$10","$11","$12","$13","$14","$15","$3b","$3c","$3d","$3e","$3f","$40","$41","$42","$43","$44","$45","$46","$47","$48","$49","$4a","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$8e"] 74:null 7a:[["$","title","0",{"children":"Reverse Polish - Flashcards | MathsGenie"}],["$","meta","1",{"name":"description","content":"Revise Reverse Polish for AQA A Level Computer Science with active-recall flashcards: flip, fill the gaps, and self-test on MathsGenie."}],["$","meta","2",{"name":"application-name","content":"MathsGenie"}],["$","meta","3",{"name":"robots","content":"index, follow"}],["$","link","4",{"rel":"canonical","href":"https://mathsgenie.co.uk/a-level/computer-science/aqa/reverse-polish/flashcards"}],["$","meta","5",{"property":"og:title","content":"Reverse Polish - Flashcards"}],["$","meta","6",{"property":"og:description","content":"Revise Reverse Polish for AQA A Level Computer Science with active-recall flashcards: flip, fill the gaps, and self-test on MathsGenie."}],["$","meta","7",{"property":"og:url","content":"https://mathsgenie.co.uk/a-level/computer-science/aqa/reverse-polish/flashcards"}],["$","meta","8",{"property":"og:site_name","content":"MathsGenie"}],["$","meta","9",{"property":"og:locale","content":"en_GB"}],["$","meta","10",{"property":"og:image","content":"https://mathsgenie.co.uk/api/og?title=Reverse%20Polish%20-%20Flashcards"}],["$","meta","11",{"property":"og:image:width","content":"1200"}],["$","meta","12",{"property":"og:image:height","content":"630"}],["$","meta","13",{"property":"og:image:alt","content":"Reverse Polish - Flashcards"}],["$","meta","14",{"property":"og:type","content":"website"}],["$","meta","15",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","16",{"name":"twitter:title","content":"Reverse Polish - Flashcards"}],["$","meta","17",{"name":"twitter:description","content":"Revise Reverse Polish for AQA A Level Computer Science with active-recall flashcards: flip, fill the gaps, and self-test on MathsGenie."}],["$","meta","18",{"name":"twitter:image","content":"https://mathsgenie.co.uk/api/og?title=Reverse%20Polish%20-%20Flashcards"}],["$","link","19",{"rel":"icon","href":"/favicon.ico?favicon.2j0dv-gmf2vmi.ico?dpl=nogit-1793629803","sizes":"256x256","type":"image/x-icon"}],["$","link","20",{"rel":"icon","href":"/icon.svg?icon.0odudpcuyu_1t.svg?dpl=nogit-1793629803","sizes":"any","type":"image/svg+xml"}],["$","link","21",{"rel":"apple-touch-icon","href":"/apple-icon.png?apple-icon.3cq-u4n9i7l9o.png?dpl=nogit-1793629803","sizes":"180x180","type":"image/png"}],["$","$L86","22",{}]] 71:[["$","$L87",null,{"feature":"flashcards"}],"$L88",["$","$L8a",null,{"href":"/a-level/computer-science/aqa/reverse-polish/flashcards","label":"Reverse Polish","subjectCode":"a_level_computer_science__aqa","surface":"flashcards"}],["$","$L8b",null,{"kind":"flashcards","topicId":"d12eacb1-66d8-5416-9148-b3a89b73bd6a"}],["$","$L8d",null,{"runner":["$","div",null,{"className":"min-h-0 flex-1 overflow-hidden bg-background","children":["$","$L8f",null,{"decks":[{"id":"68beceba-41bc-4cb0-afb2-a4c0cff7b1e7","title":"Reverse Polish Flashcards","topicId":"d12eacb1-66d8-5416-9148-b3a89b73bd6a","topicSlug":"reverse-polish","cards":[{"id":"9f9c105d-4c9f-4f7b-95da-7b966151207e","cardType":"cloze","points":null,"front":"In [ ], each binary operator is written between its two operands.","back":"In infix notation, each binary operator is written between its two operands.","mcqOptions":[{"text":"infix notation","correct":true,"explanation":"Infix notation places each binary operator between its operands, as in A + B. This is the conventional notation used for most written arithmetic expressions."},{"text":"prefix notation","correct":false,"explanation":"Prefix notation places the operator before both operands, as in + A B. The notation with the operator between the operands is infix notation."},{"text":"postfix notation","correct":false,"explanation":"Postfix notation places the operator after both operands, as in A B +. An operator written between its operands uses infix notation."},{"text":"Reverse Polish notation","correct":false,"explanation":"Reverse Polish notation is another name for postfix notation, where operators follow their operands. Operators placed between their operands are written in infix notation."}]},{"id":"d77d741f-26e6-421b-a1d0-e77662af9367","cardType":"cloze","points":null,"front":"In [ ], also called postfix notation, each operator is written after its operands.","back":"In Reverse Polish notation, also called postfix notation, each operator is written after its operands.","mcqOptions":[{"text":"Reverse Polish notation","correct":true,"explanation":"Reverse Polish notation is postfix notation: each operator follows the operands on which it acts, so A + B becomes A B +."},{"text":"infix notation","correct":false,"explanation":"Infix notation places an operator between its operands, rather than after them. Postfix notation, in which the operator follows its operands, is called Reverse Polish notation."},{"text":"prefix notation","correct":false,"explanation":"Prefix notation puts an operator before its operands, as in + A B. Reverse Polish notation puts it after them, as in A B +."},{"text":"algebraic notation","correct":false,"explanation":"Algebraic notation commonly refers to conventional infix expressions and is not the name for postfix form. Postfix notation is specifically called Reverse Polish notation."}]},{"id":"727cb592-8e3b-4c84-a912-6a3d0ff2d8e0","cardType":"basic","points":2,"front":"Why is B + A not the RPN form of A + B?","back":"Operands keep their left-to-right order; only the operator moves.","mcqOptions":[{"text":"Operands keep their left-to-right order; only the operator moves.","correct":true,"explanation":"Converting A + B to RPN preserves the operand sequence and moves the operator after it, producing A B +, not B + A."},{"text":"Operands reverse their left-to-right order; the operator stays in place.","correct":false,"explanation":"RPN conversion does not reverse operands or leave the operator between them. The operands remain in their original order and the operator moves after them, giving A B +."},{"text":"Operands may swap their left-to-right order when the operator is commutative.","correct":false,"explanation":"Commutativity may preserve the arithmetic result, but it does not define the correct syntactic conversion. Operand order stays unchanged and only the operator moves, producing A B +."},{"text":"Operands keep their left-to-right order; the operator moves before them.","correct":false,"explanation":"Moving the operator before the operands produces prefix notation, not RPN. In RPN, the operands retain their left-to-right order and the operator follows them."}]},{"id":"40f6849c-aaff-4c8d-b555-d4a920081ce2","cardType":"cloze","points":null,"front":"In A + B * C, multiplication happens before addition because of [ ].","back":"In A + B * C, multiplication happens before addition because of operator precedence.","mcqOptions":[{"text":"operator precedence","correct":true,"explanation":"Operator precedence gives multiplication a higher priority than addition, so B * C is evaluated before its result is added to A."},{"text":"left associativity","correct":false,"explanation":"Left associativity resolves the order of operators that have equal precedence. Multiplication occurs before addition here because multiplication has higher operator precedence."},{"text":"commutativity","correct":false,"explanation":"Commutativity allows certain operands to be exchanged without changing a result; it does not determine which operator is evaluated first. That is determined by operator precedence."},{"text":"bracket placement","correct":false,"explanation":"There are no explicit brackets in this expression. Multiplication is performed first because operator precedence supplies the implied grouping A + (B * C)."}]},{"id":"90f175be-2228-472f-a2e8-be6723eb053f","cardType":"cloze","points":null,"front":"For simple arithmetic operators with equal precedence, work [ ] unless brackets say otherwise.","back":"For simple arithmetic operators with equal precedence, work left to right unless brackets say otherwise.","mcqOptions":[{"text":"left to right","correct":true,"explanation":"Operators of equal precedence are normally evaluated from left to right because these simple arithmetic operators are left-associative, unless brackets explicitly impose a different order."},{"text":"right to left","correct":false,"explanation":"Working right to left incorrectly reverses the usual associativity of simple equal-precedence arithmetic operators. Without brackets, they are normally evaluated from left to right."},{"text":"highest to lowest","correct":false,"explanation":"Highest to lowest describes choosing between different precedence levels, not equal-precedence operators. When precedence is equal, simple arithmetic operations are evaluated from left to right."},{"text":"inside to outside","correct":false,"explanation":"Inside to outside applies when nested brackets define an order. For unbracketed simple arithmetic operators with equal precedence, evaluation proceeds from left to right."}]},{"id":"8d6d01bf-ebd0-4ce8-80ee-bdaf2250f5f7","cardType":"basic","points":1,"front":"Before converting an unbracketed infix expression to RPN, what should you add?","back":"Add implied brackets using precedence.","mcqOptions":[{"text":"Add implied brackets using precedence.","correct":true,"explanation":"Implied brackets make the infix evaluation order explicit before conversion. Operator precedence and associativity determine the grouping, which can then be converted reliably into RPN."},{"text":"Add explicit operators between every operand.","correct":false,"explanation":"The infix expression already contains the necessary operators, so adding more would change it. Instead, add implied brackets using precedence to expose the intended operation order."},{"text":"Add brackets from right to left throughout.","correct":false,"explanation":"Bracketing mechanically from right to left can contradict precedence and associativity. Implied brackets must be added according to the expression’s operator precedence before conversion."},{"text":"Add a bracket around each token separately.","correct":false,"explanation":"Bracketing individual tokens does not show which operands belong to each operation. Add implied brackets using precedence so the expression’s operation groups become explicit."}]},{"id":"ecea61d0-7d10-4a00-a7b3-b081d688b597","cardType":"basic","points":2,"front":"Why are brackets not needed in RPN?","back":"Operation order is built into the token order.","mcqOptions":[{"text":"Operation order is built into the token order.","correct":true,"explanation":"In RPN, each operator appears after the operands or intermediate results it uses. This token sequence uniquely determines the evaluation order, so brackets are unnecessary."},{"text":"Operator precedence is retained by the operator symbols.","correct":false,"explanation":"RPN does not rely on conventional precedence rules encoded by operator symbols. Operation order is determined entirely by token order, making brackets unnecessary."},{"text":"All operators are evaluated in left-to-right order.","correct":false,"explanation":"RPN is scanned left to right, but an operator executes only after its required operands are available. The complete token order, not a blanket left-to-right rule, fixes evaluation."},{"text":"Each operation uses only a single operand.","correct":false,"explanation":"Binary RPN operators still use two operands, usually taken from a stack. Brackets are unnecessary because token order specifies which values each operator consumes."}]},{"id":"08f8c844-b384-451a-98ed-c677d7d19012","cardType":"cloze","points":null,"front":"A stack is [ ]; pop removes the top item.","back":"A stack is last-in, first-out; pop removes the top item.","mcqOptions":[{"text":"last-in, first-out","correct":true,"explanation":"A stack removes its most recently added item first. This last-in, first-out behaviour means both push and pop operate at the top of the stack."},{"text":"first-in, first-out","correct":false,"explanation":"First-in, first-out describes a queue, where the oldest item leaves first. A stack instead removes the newest item first, so it is last-in, first-out."},{"text":"last-in, last-out","correct":false,"explanation":"This reverses the defining removal rule for a stack. The last item pushed is the first item popped, so a stack is last-in, first-out."},{"text":"highest-priority, first-out","correct":false,"explanation":"Highest-priority, first-out describes a priority queue rather than a stack. A stack ignores priority and pops the most recently added item, following last-in, first-out."}]},{"id":"6363d312-b52a-4457-9a5a-864f3ed8a0af","cardType":"cloze","points":null,"front":"During stack evaluation of RPN, tokens are read [ ].","back":"During stack evaluation of RPN, tokens are read left to right.","mcqOptions":[{"text":"left to right","correct":true,"explanation":"RPN is evaluated by scanning tokens from left to right, pushing operands as they appear and applying each operator to the appropriate values on the stack."},{"text":"right to left","correct":false,"explanation":"Scanning right to left reverses the intended token sequence and gives operators the wrong operands. RPN tokens must be read from left to right during evaluation."},{"text":"in precedence order","correct":false,"explanation":"Operator precedence is already encoded by the token order in RPN, so no precedence sorting is needed. Tokens are simply read from left to right."},{"text":"operators before operands","correct":false,"explanation":"Processing operators first would leave no stored values for them to use. Tokens are read from left to right, with operands pushed before their following operators are applied."}]},{"id":"ac1c2279-06c2-48f1-925d-1d43549e206f","cardType":"basic","points":1,"front":"During RPN evaluation, what do you do with an operand token?","back":"Push it onto the stack.","mcqOptions":[{"text":"Push it onto the stack.","correct":true,"explanation":"An operand is a value needed by a later operator, so it is pushed onto the stack and remains there until an operator pops it."},{"text":"Pop it from the stack.","correct":false,"explanation":"Popping is used to retrieve operands when an operator is processed, not when an operand token is encountered. An operand token must be pushed onto the stack."},{"text":"Apply it to the stack.","correct":false,"explanation":"Only operators are applied to values; an operand is itself a value. It must be pushed onto the stack for use by a later operator."},{"text":"Discard it from the stack.","correct":false,"explanation":"Discarding the operand would remove information required by a later calculation. Each operand token must instead be pushed onto the stack."}]},{"id":"d5be4625-26aa-4784-93ef-c04124a6f514","cardType":"basic","points":1,"front":"During RPN evaluation, which operand is popped first for a binary operator?","back":"The right-hand operand.","mcqOptions":[{"text":"The right-hand operand.","correct":true,"explanation":"For a binary operator, the first value popped is the right-hand operand and the second is the left-hand operand, preserving the intended order."},{"text":"The left-hand operand.","correct":false,"explanation":"Confusing pop order with expression order reverses non-commutative operations such as subtraction. The right-hand operand is popped first, followed by the left-hand operand."},{"text":"The first operand read.","correct":false,"explanation":"The first operand read is normally lower in the stack and is not popped first. The most recently pushed, right-hand operand is popped first."},{"text":"The bottom-most operand.","correct":false,"explanation":"A stack follows last in, first out, so evaluation does not begin by removing its bottom value. The right-hand operand at the top is popped first."}]},{"id":"452c009e-4add-4a15-83cb-0a84b4543f3e","cardType":"basic","points":1,"front":"What infix expression does RPN A B - represent?","back":"A - B","mcqOptions":[{"text":"A - B","correct":true,"explanation":"The operator follows both operands in RPN. The first operand, A, is the left-hand value and B is the right-hand value, giving A - B."},{"text":"B - A","correct":false,"explanation":"This reverses the operands by treating the first popped value as the left-hand one. In A B -, B is popped first but remains the right-hand operand, so the result is A - B."},{"text":"A + B","correct":false,"explanation":"The final token specifies subtraction, not addition. The operands retain their written order in the equivalent infix expression, so the expression is A - B."},{"text":"A / B","correct":false,"explanation":"The operator token is a minus sign, so interpreting it as division changes the operation. The corresponding infix expression is A - B."}]},{"id":"17a20983-e882-460b-aba6-672698927ccc","cardType":"basic","points":1,"front":"After applying an operator during RPN evaluation, what happens to the result?","back":"Push the result back onto the stack.","mcqOptions":[{"text":"Push the result back onto the stack.","correct":true,"explanation":"The result may be needed as an operand by a later operator, so it is pushed back onto the stack after the current operation is completed."},{"text":"Discard the result from the stack.","correct":false,"explanation":"Discarding an intermediate result would prevent later operators from using it. The result must be pushed back onto the stack as a new operand."},{"text":"Print the result beside the stack.","correct":false,"explanation":"RPN evaluation does not output every intermediate value. After applying an operator, its result is pushed back onto the stack for possible further calculation."},{"text":"Pop the result back from the stack.","correct":false,"explanation":"Popping removes a value and would make the result unavailable to later operators. The newly calculated result must instead be pushed back onto the stack."}]},{"id":"306b9435-321a-4647-a6f2-95e8090c93e0","cardType":"cloze","points":null,"front":"At the end of valid RPN evaluation, the stack contains exactly [ ]: the final result.","back":"At the end of valid RPN evaluation, the stack contains exactly one item: the final result.","mcqOptions":[{"text":"one item","correct":true,"explanation":"A valid, complete RPN expression combines all operands through its operators, leaving exactly one stack item. That remaining item is the final result."},{"text":"two items","correct":false,"explanation":"Two remaining items indicate that the expression has not combined all its values, usually because an operator is missing. Valid RPN evaluation ends with exactly one item."},{"text":"no items","correct":false,"explanation":"An empty stack means the final result has been removed or the expression was malformed. Valid evaluation leaves exactly one item containing the final result."},{"text":"all intermediate results","correct":false,"explanation":"Intermediate results are consumed as operands by later operators rather than retained separately. A valid completed RPN expression leaves only one item, the final result."}]},{"id":"4d7303cb-bd66-458a-8362-44115f2c162b","cardType":"basic","points":1,"front":"Convert infix (A + B) * C to RPN.","back":"A B + C *","mcqOptions":[{"text":"A B + C *","correct":true,"explanation":"The parentheses require A + B to be evaluated first, producing A B +. That result is then multiplied by C, giving A B + C *."},{"text":"A B C * +","correct":false,"explanation":"This evaluates B * C before adding A, representing A + (B * C). The brackets require addition first, so the correct RPN is A B + C *."},{"text":"A B + * C","correct":false,"explanation":"The multiplication operator appears before its second operand, C, so this is not a valid ordering for the expression. The correct sequence is A B + C *."},{"text":"A B C + *","correct":false,"explanation":"This adds B and C first and then multiplies by A, representing A * (B + C). The correct RPN is A B + C *."}]},{"id":"9f95e32f-91bd-46b0-b7e8-f973b1cee244","cardType":"basic","points":1,"front":"Convert infix A + B * C to RPN.","back":"A B C * +","mcqOptions":[{"text":"A B C * +","correct":true,"explanation":"Multiplication has higher precedence than addition, so B * C is formed first as B C *. Adding A then gives A B C * +."},{"text":"A B + C *","correct":false,"explanation":"This applies addition before multiplication, representing (A + B) * C. Without parentheses, multiplication has priority, so the correct RPN is A B C * +."},{"text":"A B C + *","correct":false,"explanation":"This evaluates B + C and then multiplies the result by A, representing A * (B + C). The correct RPN is A B C * +."},{"text":"A B * C +","correct":false,"explanation":"This multiplies A by B before adding C, representing (A * B) + C. The required multiplication is B * C, giving A B C * +."}]},{"id":"d4047df9-bee0-45e0-b640-9955283c0e81","cardType":"basic","points":2,"front":"Fully bracket A + B * C - D using precedence and associativity.","back":"((A + (B * C)) - D)","mcqOptions":[{"text":"((A + (B * C)) - D)","correct":true,"explanation":"Multiplication has higher precedence than addition, so B * C is grouped first. Addition and subtraction then associate from left to right, placing the final subtraction outermost."},{"text":"(((A + B) * C) - D)","correct":false,"explanation":"This incorrectly performs A + B before multiplication. Multiplication has higher precedence, so the correct bracketing is ((A + (B * C)) - D)."},{"text":"(A + ((B * C) - D))","correct":false,"explanation":"This wrongly groups the subtraction before the addition. Since addition and subtraction have equal precedence and associate left to right, the correct form is ((A + (B * C)) - D)."},{"text":"((A + B) * (C - D))","correct":false,"explanation":"This introduces two groupings that are not implied by precedence. B * C must be evaluated first, giving the correct form ((A + (B * C)) - D)."}]},{"id":"709249e0-3d3a-43df-b85e-3803ab9bafa4","cardType":"basic","points":2,"front":"Convert infix A + B * C - D to RPN.","back":"A B C * + D -","mcqOptions":[{"text":"A B C * + D -","correct":true,"explanation":"B and C are multiplied first, that result is added to A, and D is then subtracted. Each operator therefore follows the operands or intermediate results it uses."},{"text":"A B + C * D -","correct":false,"explanation":"This sequence represents ((A + B) * C) - D, incorrectly performing addition before multiplication. The correct RPN is A B C * + D -."},{"text":"A B C * D - +","correct":false,"explanation":"This sequence represents A + ((B * C) - D), incorrectly doing the subtraction before the outer addition. The correct RPN is A B C * + D -."},{"text":"A B C + * D -","correct":false,"explanation":"This sequence adds B and C before multiplying by A, representing (A * (B + C)) - D. The correct RPN is A B C * + D -."}]},{"id":"80bbadc2-21de-4884-b22d-68a595cb38f9","cardType":"basic","points":1,"front":"When converting RPN back to infix, what does the stack store?","back":"Expression fragments.","mcqOptions":[{"text":"Expression fragments.","correct":true,"explanation":"Each operator combines the top two stored fragments into a new bracketed infix expression. That larger expression fragment is then pushed back for use by later operators."},{"text":"Individual operators.","correct":false,"explanation":"Operators trigger the combination of two stack entries rather than remaining as the stored entries. The stack holds expression fragments, including single operands and newly combined expressions."},{"text":"Only numeric values.","correct":false,"explanation":"That describes evaluation of numeric RPN, not conversion back to infix. During conversion, the stack must hold expression fragments so their structure and operators are preserved."},{"text":"Operator precedences.","correct":false,"explanation":"RPN already encodes the required evaluation order, so precedence values need not be stored. The stack instead holds expression fragments that are combined when operators are encountered."}]},{"id":"536171e9-aa1b-4cdd-ae37-f3f644dcf8bb","cardType":"basic","points":2,"front":"Convert RPN A B C * + D - to fully bracketed infix.","back":"((A + (B * C)) - D)","mcqOptions":[{"text":"((A + (B * C)) - D)","correct":true,"explanation":"The * combines B and C, the + combines A with that fragment, and the final - subtracts D. Brackets show each combination explicitly."},{"text":"(((A + B) * C) - D)","correct":false,"explanation":"This corresponds to A B + C * D -, with addition occurring before multiplication. The given RPN instead converts to ((A + (B * C)) - D)."},{"text":"(A + ((B * C) - D))","correct":false,"explanation":"This corresponds to A B C * D - +, where D is subtracted before A is added. The given RPN converts to ((A + (B * C)) - D)."},{"text":"((A * (B + C)) - D)","correct":false,"explanation":"This incorrectly treats + as combining B and C before multiplication by A. In the given RPN, * first combines B and C, producing ((A + (B * C)) - D)."}]},{"id":"18a314fc-78a6-4a37-934e-61d2c0d56d7a","cardType":"basic","points":2,"front":"Evaluate RPN 3 4 2 * +.","back":"11","mcqOptions":[{"text":"11","correct":true,"explanation":"Push 3, 4 and 2; multiplication pops 4 and 2 to produce 8. Addition then combines 3 and 8, giving 11."},{"text":"14","correct":false,"explanation":"This comes from evaluating (3 + 4) * 2, which ignores the postfix positions of the operators. Multiplication occurs first in the given RPN, so the answer is 11."},{"text":"10","correct":false,"explanation":"This results from multiplying 3 by 2 and then adding 4, using non-adjacent stack operands. The * actually combines 4 and 2, so the answer is 11."},{"text":"24","correct":false,"explanation":"This treats every operand as if it were joined by multiplication. The final operator is +, so 3 is added to 4 * 2, producing 11."}]},{"id":"527e9e74-c432-48f0-ba84-e73a3543b593","cardType":"basic","points":2,"front":"Why is RPN suitable for stack-based interpreters?","back":"

Operands are pushed onto the stack.
Operators pop operands and push results.

","mcqOptions":[{"text":"

Operands are pushed onto the stack.
Operators pop operands and push results.

","correct":true,"explanation":"RPN presents operands before their operator, so values can be pushed as encountered. An operator then uses the top operands and returns its result to the same stack."},{"text":"

Operators are pushed onto the stack.
Operands pop operators and push results.

","correct":false,"explanation":"This reverses the roles of operands and operators. Operands are pushed onto the stack, while each operator pops the required operands and pushes the calculated result."},{"text":"

Operands are added to a queue.
Operators remove the oldest operands first.

","correct":false,"explanation":"A queue uses first-in, first-out access, which does not match RPN evaluation. RPN uses a stack, with operators popping the most recently pushed operands and pushing results."},{"text":"

Precedence is stored on the stack.
Brackets determine when results are pushed.

","correct":false,"explanation":"RPN encodes evaluation order directly, so neither stored precedence nor brackets are required. Operands are pushed, and operators pop those operands before pushing their results."}]},{"id":"051de87b-8161-48b1-9c26-4a03d379f9f3","cardType":"basic","points":1,"front":"Name one AQA example of a system using RPN-style expression handling.","back":"PostScript or bytecode interpreters.","mcqOptions":[{"text":"PostScript or bytecode interpreters.","correct":true,"explanation":"PostScript uses postfix notation directly, while many bytecode interpreters execute instructions using an operand stack. Both are standard examples of RPN-style expression handling."},{"text":"HTML or CSS renderers.","correct":false,"explanation":"HTML and CSS describe document structure and presentation rather than serving as AQA examples of postfix stack evaluation. The named examples are PostScript or bytecode interpreters."},{"text":"SQL databases or file servers.","correct":false,"explanation":"Databases and file servers are not the specified examples of RPN-style expression handling. AQA identifies PostScript or bytecode interpreters, which process postfix operations using stacks."},{"text":"TCP routers or Ethernet switches.","correct":false,"explanation":"Routers and switches forward network traffic rather than exemplifying stack-based postfix expression evaluation. Suitable AQA examples are PostScript or bytecode interpreters."}]}]}],"examCountdown":{"examDate":"2027-06-07","paperLabel":"Paper 1"},"heading":"Reverse Polish","title":"Reverse Polish Flashcards","topbar":{"backHref":"/a-level/computer-science/aqa/flashcards"},"topicSidebar":"$L90"}]}],"topicId":"d12eacb1-66d8-5416-9148-b3a89b73bd6a","walled":"$L91"}],"$L92","$L93"]