There is a question doing the rounds on Facebook as to the correct
answer to this expression https://i.postimg.cc/Yqk0sL0j/Image1.png

9
---------
9 / 9 / 9

or (for Brian Gaff) a fraction whose numerator is 9 and whose
denominator is 9 division-sign 9 division-sign 9

Three possible answers are given: 1, 9, 81

My understanding is that the denominator 9 / 9 / 9 is *defined* to be
parsed from left to right because both operators are the same, and
therefore it is parsed as (9/9)/9 = 1/9 rather than 9/(9/9) = 9. And
hence the value of the overall expression is 9 / (1/9) = 81.

But is there an online source which supports the left-to-right order of
parsing? Is it more of a common convention than a
there-is-only-one-answer rule?

It's one of those things that probably wouldn't arise in practice
because if there was the slightest chance that it could be parsed in
different ways, you'd use explicit brackets to remove any doubt and to
force the answer that you want, but that would take the fun out of these
Facebook "puzzles" ;-)

On 5/1/2024 5:28 PM, NY wrote:
> There is a question doing the rounds on Facebook as to the correct answer to this expression https://i.postimg.cc/Yqk0sL0j/Image1.png
>
>     9
> ---------
> 9 / 9 / 9
>
> or (for Brian Gaff) a fraction whose numerator is 9 and whose denominator is 9 division-sign 9 division-sign 9
>
> Three possible answers are given: 1, 9, 81
>
>
> My understanding is that the denominator 9 / 9 / 9 is *defined* to be parsed from left to right because both operators are the same, and therefore it is parsed as (9/9)/9 = 1/9 rather than 9/(9/9) = 9. And hence the value of the overall expression is 9 / (1/9) = 81.
>
>
> But is there an online source which supports the left-to-right order of parsing? Is it more of a common convention than a there-is-only-one-answer rule?
>
>
> It's one of those things that probably wouldn't arise in practice because if there was the slightest chance that it could be parsed in different ways, you'd use explicit brackets to remove any doubt and to force the answer that you want, but that would take the fun out of these Facebook "puzzles" ;-)

A jokey question deserves a jokey answer.

https://rosettacode.org/wiki/Arithmetic_evaluation#C

C++
Works with: g++ version clang++

This version does not require boost. It works by:
- converting infix strings to postfix strings using shunting yard algorithm
- converting postfix expression to list of tokens
- builds AST bottom up from list of tokens
- evaluates expression tree by performing postorder traversal.

g++ -o parse-crispies.exe parse-crispies.cc # For the Windows users :-) I always like to throw in the compile line.

**************************************** parse-crispies.cc ****************************************
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

template <class T>
class stack {
private:
vector<T> st;
T sentinel;
public:
stack() { sentinel = T(); }
bool empty() { return st.empty(); }
void push(T info) { st.push_back(info); }
T& top() {
if (!st.empty()) {
return st.back();
}
return sentinel;
}
T pop() {
T ret = top();
if (!st.empty()) st.pop_back();
return ret;
}
};

//determine associativity of operator, returns true if left, false if right
bool leftAssociate(char c) {
switch (c) {
case '^': return false;
case '*': return true;
case '/': return true;
case '%': return true;
case '+': return true;
case '-': return true;
default:
break;
}
return false;
}

//determins precedence level of operator
int precedence(char c) {
switch (c) {
case '^': return 7;
case '*': return 5;
case '/': return 5;
case '%': return 5;
case '+': return 3;
case '-': return 3;
default:
break;
}
return 0;
}

//converts infix expression string to postfix expression string
string shuntingYard(string expr) {
stack<char> ops;
string output;
for (char c : expr) {
if (c == '(') {
ops.push(c);
} else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '%') {
if (precedence(c) < precedence(ops.top()) ||
(precedence(c) == precedence(ops.top()) && leftAssociate(c))) {
output.push_back(' ');
output.push_back(ops.pop());
output.push_back(' ');
ops.push(c);
} else {
ops.push(c);
output.push_back(' ');
}
} else if (c == ')') {
while (!ops.empty()) {
if (ops.top() != '(') {
output.push_back(ops.pop());
} else {
ops.pop();
break;
}
}
} else {
output.push_back(c);
}
}
while (!ops.empty())
if (ops.top() != '(')
output.push_back(ops.pop());
else ops.pop();
cout<<"Postfix: "<<output<<endl;
return output;
}

struct Token {
int type;
union {
double num;
char op;
};
Token(double n) : type(0), num(n) { }
Token(char c) : type(1), op(c) { }
};

//converts postfix expression string to vector of tokens
vector<Token> lex(string pfExpr) {
vector<Token> tokens;
for (int i = 0; i < pfExpr.size(); i++) {
char c = pfExpr[i];
if (isdigit(c)) {
string num;
do {
num.push_back(c);
c = pfExpr[++i];
} while (i < pfExpr.size() && isdigit(c));
tokens.push_back(Token(stof(num)));
i--;
continue;
} else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '%') {
tokens.push_back(Token(c));
}
}
return tokens;
}

//structure used for nodes of expression tree
struct node {
Token token;
node* left;
node* right;
node(Token tok) : token(tok), left(nullptr), right(nullptr) { }
};

//builds expression tree from vector of tokens
node* buildTree(vector<Token> tokens) {
cout<<"Building Expression Tree: "<<endl;
stack<node*> sf;
for (int i = 0; i < tokens.size(); i++) {
Token c = tokens[i];
if (c.type == 1) {
node* x = new node(c);
x->right = sf.pop();
x->left = sf.pop();
sf.push(x);
cout<<"Push Operator Node: "<<sf.top()->token.op<<endl;
} else
if (c.type == 0) {
sf.push(new node(c));
cout<<"Push Value Node: "<<c.num<<endl;
continue;
}
}
return sf.top();
}

//evaluate expression tree, while anotating steps being performed.
int recd = 0;
double eval(node* x) {
recd++;
if (x == nullptr) {
recd--;
return 0;
}
if (x->token.type == 0) {
for (int i = 0; i < recd; i++) cout<<" ";
cout<<"Value Node: "<<x->token.num<<endl;
recd--;
return x->token.num;
}
if (x->token.type == 1) {
for (int i = 0; i < recd; i++) cout<<" ";
cout<<"Operator Node: "<<x->token.op<<endl;
double lhs = eval(x->left);
double rhs = eval(x->right);
for (int i = 0; i < recd; i++) cout<<" ";
cout<<lhs<<" "<<x->token.op<<" "<<rhs<<endl;
recd--;
switch (x->token.op) {
case '^': return pow(lhs, rhs);
case '*': return lhs*rhs;
case '/':
if (rhs == 0) {
cout<<"Error: divide by zero."<<endl;
} else
return lhs/rhs;
case '%':
return (int)lhs % (int)rhs;
case '+': return lhs+rhs;
case '-': return lhs-rhs;
default:
break;
}
}
return 0;
}

int main() {
// string expr = "3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3";
string expr = "9 / 9 / 9 / 9"; // Your desired expression goes here

cout<<eval(buildTree(lex(shuntingYard(expr))))<<endl;
return 0;
}

**************************************** end parse-crispies.cc ****************************************

$ parse-crispies.exe
Postfix: 9 9 / 9 / 9/
Building Expression Tree:
Push Value Node: 9
Push Value Node: 9
Push Operator Node: /
Push Value Node: 9
Push Operator Node: /
Push Value Node: 9
Push Operator Node: /
Operator Node: /
Operator Node: /
Operator Node: /
Value Node: 9
Value Node: 9
9 / 9
Value Node: 9
1 / 9
Value Node: 9
0.111111 / 9
0.0123457

Which is, roughly speaking, 1/81

On 02/05/2024 00:05, Paul wrote:

Apart from the fact that "9 / 9 / 9 / 9" isn't the same as the question
uses (*), this proves the point: it evaluates "9 / 9 / 9" as 0.111111 or
1/9, and then if you do the initial 9 / 0.111111111 division *last*
instead of first, then the overall answer would be 81.

(*) The long line of a numerator / denominator fraction is executed
last, not first, so you fully evaluate the numerator and the
denominator, then evaluate the fraction.

> **************************************** parse-crispies.cc ****************************************
> #include <iostream>
> #include <vector>
> #include <cmath>
> using namespace std;
>
> template <class T>
> class stack {
> private:
> vector<T> st;
> T sentinel;
> public:
> stack() { sentinel = T(); }
> bool empty() { return st.empty(); }
> void push(T info) { st.push_back(info); }
> T& top() {
> if (!st.empty()) {
> return st.back();
> }
> return sentinel;
> }
> T pop() {
> T ret = top();
> if (!st.empty()) st.pop_back();
> return ret;
> }
> };
>
> //determine associativity of operator, returns true if left, false if right
> bool leftAssociate(char c) {
> switch (c) {
> case '^': return false;
> case '*': return true;
> case '/': return true;
> case '%': return true;
> case '+': return true;
> case '-': return true;
> default:
> break;
> }
> return false;
> }
>
> //determins precedence level of operator
> int precedence(char c) {
> switch (c) {
> case '^': return 7;
> case '*': return 5;
> case '/': return 5;
> case '%': return 5;
> case '+': return 3;
> case '-': return 3;
> default:
> break;
> }
> return 0;
> }
>
> //converts infix expression string to postfix expression string
> string shuntingYard(string expr) {
> stack<char> ops;
> string output;
> for (char c : expr) {
> if (c == '(') {
> ops.push(c);
> } else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '%') {
> if (precedence(c) < precedence(ops.top()) ||
> (precedence(c) == precedence(ops.top()) && leftAssociate(c))) {
> output.push_back(' ');
> output.push_back(ops.pop());
> output.push_back(' ');
> ops.push(c);
> } else {
> ops.push(c);
> output.push_back(' ');
> }
> } else if (c == ')') {
> while (!ops.empty()) {
> if (ops.top() != '(') {
> output.push_back(ops.pop());
> } else {
> ops.pop();
> break;
> }
> }
> } else {
> output.push_back(c);
> }
> }
> while (!ops.empty())
> if (ops.top() != '(')
> output.push_back(ops.pop());
> else ops.pop();
> cout<<"Postfix: "<<output<<endl;
> return output;
> }
>
> struct Token {
> int type;
> union {
> double num;
> char op;
> };
> Token(double n) : type(0), num(n) { }
> Token(char c) : type(1), op(c) { }
> };
>
> //converts postfix expression string to vector of tokens
> vector<Token> lex(string pfExpr) {
> vector<Token> tokens;
> for (int i = 0; i < pfExpr.size(); i++) {
> char c = pfExpr[i];
> if (isdigit(c)) {
> string num;
> do {
> num.push_back(c);
> c = pfExpr[++i];
> } while (i < pfExpr.size() && isdigit(c));
> tokens.push_back(Token(stof(num)));
> i--;
> continue;
> } else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '%') {
> tokens.push_back(Token(c));
> }
> }
> return tokens;
> }
>
> //structure used for nodes of expression tree
> struct node {
> Token token;
> node* left;
> node* right;
> node(Token tok) : token(tok), left(nullptr), right(nullptr) { }
> };
>
> //builds expression tree from vector of tokens
> node* buildTree(vector<Token> tokens) {
> cout<<"Building Expression Tree: "<<endl;
> stack<node*> sf;
> for (int i = 0; i < tokens.size(); i++) {
> Token c = tokens[i];
> if (c.type == 1) {
> node* x = new node(c);
> x->right = sf.pop();
> x->left = sf.pop();
> sf.push(x);
> cout<<"Push Operator Node: "<<sf.top()->token.op<<endl;
> } else
> if (c.type == 0) {
> sf.push(new node(c));
> cout<<"Push Value Node: "<<c.num<<endl;
> continue;
> }
> }
> return sf.top();
> }
>
> //evaluate expression tree, while anotating steps being performed.
> int recd = 0;
> double eval(node* x) {
> recd++;
> if (x == nullptr) {
> recd--;
> return 0;
> }
> if (x->token.type == 0) {
> for (int i = 0; i < recd; i++) cout<<" ";
> cout<<"Value Node: "<<x->token.num<<endl;
> recd--;
> return x->token.num;
> }
> if (x->token.type == 1) {
> for (int i = 0; i < recd; i++) cout<<" ";
> cout<<"Operator Node: "<<x->token.op<<endl;
> double lhs = eval(x->left);
> double rhs = eval(x->right);
> for (int i = 0; i < recd; i++) cout<<" ";
> cout<<lhs<<" "<<x->token.op<<" "<<rhs<<endl;
> recd--;
> switch (x->token.op) {
> case '^': return pow(lhs, rhs);
> case '*': return lhs*rhs;
> case '/':
> if (rhs == 0) {
> cout<<"Error: divide by zero."<<endl;
> } else
> return lhs/rhs;
> case '%':
> return (int)lhs % (int)rhs;
> case '+': return lhs+rhs;
> case '-': return lhs-rhs;
> default:
> break;
> }
> }
> return 0;
> }
>
> int main() {
> // string expr = "3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3";
> string expr = "9 / 9 / 9 / 9"; // Your desired expression goes here
>
> cout<<eval(buildTree(lex(shuntingYard(expr))))<<endl;
> return 0;
> }

On 5/1/2024 7:50 PM, NY wrote:

> (*) The long line of a numerator / denominator fraction is executed last, not first, so you fully evaluate the numerator and the denominator, then evaluate the fraction.

https://www.cnet.com/a/img/resize/97cd348f6d692a4492696b306fa359063a51b7e3/hub/2019/05/22/f9ac1a6a-e900-4095-9357-19e2369892f7/saucy-picard-meme.jpg?auto=webp&precrop=645,593,x0,y28&width=1200

Paul

On 5/1/2024 7:50 PM, NY wrote:
> On 02/05/2024 00:05, Paul wrote:
>
> Apart from the fact that "9 / 9 / 9 / 9" isn't the same as the question uses (*), this proves the point: it evaluates "9 / 9 / 9" as 0.111111 or 1/9, and then if you do the initial 9 / 0.111111111 division *last* instead of first, then the overall answer would be 81.
>
> (*) The long line of a numerator / denominator fraction is executed last, not first, so you fully evaluate the numerator and the denominator, then evaluate the fraction.
>

I see that providing the program, was unintentionally a good idea.

As a thought experiment, pick up your calculator.

How many division symbols are on it ? [one]

Does the calculator have a "long horizontal line" and a "regular division" symbol ? [no]

There is no instantiation of a long horizontal line with magic properties, on computers.

There are only the rules of operator precedence.

If you, as a mathematician, wish to communicate with other mathematicians,
then you use accepted notation, with accepted operator precedence.

In cases where there is the possibility of an ambiguity (such as drawing
a long line, and wishing the audience to interpret it a certain way),
then you have the option of adding additional symbols, so that there is
no ambiguity about what you intend.

*******

Now, pick up that computer program. The C++ program I provided (from Rosetta).

Go to the input line.

Craft an expression that the program will use to achieve the answer you want.

Now, go back to your Facebook diagram and add the missing two items to the drawing.

Then, surprise us.

*******

https://en.wikipedia.org/wiki/Order_of_operations

[Picture]

https://i.postimg.cc/N0rvb7tW/division.gif

Paul

On 01/05/2024 22:28, NY wrote:
> There is a question doing the rounds on Facebook as to the correct
> answer to this expression https://i.postimg.cc/Yqk0sL0j/Image1.png
>
>     9
> ---------
> 9 / 9 / 9
>
> or (for Brian Gaff) a fraction whose numerator is 9 and whose
> denominator is 9 division-sign 9 division-sign 9
>
> Three possible answers are given: 1, 9, 81
>
>
> My understanding is that the denominator 9 / 9 / 9 is *defined* to be
> parsed from left to right because both operators are the same, and
> therefore it is parsed as (9/9)/9 = 1/9 rather than 9/(9/9) = 9. And
> hence the value of the overall expression is 9 / (1/9) = 81.
>
>
> But is there an online source which supports the left-to-right order of
> parsing? Is it more of a common convention than a
> there-is-only-one-answer rule?
>
>
> It's one of those things that probably wouldn't arise in practice
> because if there was the slightest chance that it could be parsed in
> different ways, you'd use explicit brackets to remove any doubt and to
> force the answer that you want, but that would take the fun out of these
> Facebook "puzzles" ;-)

It's (or variants thereof) everywhere. It's called a math puzzle, but
it's a convention puzzle

--
“when things get difficult you just have to lie”

― Jean Claud Jüncker

On 2024-05-02 03:34, Paul wrote:
> On 5/1/2024 7:50 PM, NY wrote:
>> On 02/05/2024 00:05, Paul wrote:
>>
>> Apart from the fact that "9 / 9 / 9 / 9" isn't the same as the question uses (*), this proves the point: it evaluates "9 / 9 / 9" as 0.111111 or 1/9, and then if you do the initial 9 / 0.111111111 division *last* instead of first, then the overall answer would be 81.
>>
>> (*) The long line of a numerator / denominator fraction is executed last, not first, so you fully evaluate the numerator and the denominator, then evaluate the fraction.
>>
>
> I see that providing the program, was unintentionally a good idea.
>
> As a thought experiment, pick up your calculator.
>
> How many division symbols are on it ? [one]
>
> Does the calculator have a "long horizontal line" and a "regular division" symbol ? [no]
>
> There is no instantiation of a long horizontal line with magic properties, on computers.

Not quite always! On my Casio fx-991EX I can do this:

https://drive.google.com/file/d/1iYFBZHodWZjA6fza2I0wgMbn1T0wZf-R/view?usp=sharing

nib

In message <v0vc2g$3mq43$2@dont-email.me>, The Natural Philosopher
<tnp@invalid.invalid> writes
>On 01/05/2024 22:28, NY wrote:
>> There is a question doing the rounds on Facebook as to the correct
>>answer to this expression https://i.postimg.cc/Yqk0sL0j/Image1.png
>>     9
>> ---------
>> 9 / 9 / 9
>> or (for Brian Gaff) a fraction whose numerator is 9 and whose
>>denominator is 9 division-sign 9 division-sign 9
>> Three possible answers are given: 1, 9, 81
>> My understanding is that the denominator 9 / 9 / 9 is *defined* to
>>be parsed from left to right because both operators are the same, and
>>therefore it is parsed as (9/9)/9 = 1/9 rather than 9/(9/9) = 9. And
>>hence the value of the overall expression is 9 / (1/9) = 81.
>> But is there an online source which supports the left-to-right
>>order of parsing? Is it more of a common convention than a
>>there-is-only-one-answer rule?
>> It's one of those things that probably wouldn't arise in practice
>>because if there was the slightest chance that it could be parsed in
>>different ways, you'd use explicit brackets to remove any doubt and to
>>force the answer that you want, but that would take the fun out of
>>these Facebook "puzzles" ;-)
>
>It's (or variants thereof) everywhere. It's called a math puzzle, but
>it's a convention puzzle

I was 13 when *Jonnie Roscoe* taught us to follow the convention BODMAS
(brackets,oving,division,multiplication,addition,subtraction)
I have never had reason to doubt him.
>
>

--
Tim Lamb

On 5/2/2024 4:51 AM, nib wrote:
> On 2024-05-02 03:34, Paul wrote:
>> On 5/1/2024 7:50 PM, NY wrote:
>>> On 02/05/2024 00:05, Paul wrote:
>>>
>>> Apart from the fact that "9 / 9 / 9 / 9" isn't the same as the question uses (*), this proves the point: it evaluates "9 / 9 / 9" as 0.111111 or 1/9, and then if you do the initial 9 / 0.111111111 division *last* instead of first, then the overall answer would be 81.
>>>
>>> (*) The long line of a numerator / denominator fraction is executed last, not first, so you fully evaluate the numerator and the denominator, then evaluate the fraction.
>>>
>>
>> I see that providing the program, was unintentionally a good idea.
>>
>> As a thought experiment, pick up your calculator.
>>
>> How many division symbols are on it ?  [one]
>>
>> Does the calculator have a "long horizontal line" and a "regular division" symbol ? [no]
>>
>> There is no instantiation of a long horizontal line with magic properties, on computers.
>
> Not quite always! On my Casio fx-991EX I can do this:
>
> https://drive.google.com/file/d/1iYFBZHodWZjA6fza2I0wgMbn1T0wZf-R/view?usp=sharing
>
> nib

That is probably what everyone in Facebook uses.

https://www.casio.com/content/dam/casio/global/support/manuals/calculators/pdf/004-en/f/fx-570_991EX_EN.pdf

$ parse-crispies.exe
Original: 9 / ( 9 / 9 / 9 )
Postfix: 9 9 9 / 9 //
Building Expression Tree:
Push Value Node: 9
Push Value Node: 9
Push Value Node: 9
Push Operator Node: /
Push Value Node: 9
Push Operator Node: /
Push Operator Node: /
Operator Node: /
Value Node: 9
Operator Node: /
Operator Node: /
Value Node: 9
Value Node: 9
9 / 9
Value Node: 9
1 / 9
9 / 0.111111
81

Paul

On Wed, 1 May 2024 22:28:54 +0100, NY <me@privacy.net> wrote:

>There is a question doing the rounds on Facebook as to the correct
>answer to this expression https://i.postimg.cc/Yqk0sL0j/Image1.png
>
> 9
>---------
>9 / 9 / 9
>
>or (for Brian Gaff) a fraction whose numerator is 9 and whose
>denominator is 9 division-sign 9 division-sign 9
>
>Three possible answers are given: 1, 9, 81
>
>
>My understanding is that the denominator 9 / 9 / 9 is *defined* to be
>parsed from left to right because both operators are the same, and
>therefore it is parsed as (9/9)/9 = 1/9 rather than 9/(9/9) = 9. And
>hence the value of the overall expression is 9 / (1/9) = 81.
>
>
>But is there an online source which supports the left-to-right order of
>parsing? Is it more of a common convention than a
>there-is-only-one-answer rule?
>
>
>It's one of those things that probably wouldn't arise in practice
>because if there was the slightest chance that it could be parsed in
>different ways, you'd use explicit brackets to remove any doubt and to
>force the answer that you want, but that would take the fun out of these
>Facebook "puzzles" ;-)

FWIW LibreCalc and an old Excel both give 81 assuming it is parsed as
9/(9/9/9/)

--
AnthonyL

Why ever wait to finish a job before starting the next?

In message <gw2dne6pMaGFKa_7nZ2dnZfqnPidnZ2d@brightview.co.uk>, NY
<me@privacy.net> writes
>There is a question doing the rounds on Facebook as to the correct
>answer to this expression https://i.postimg.cc/Yqk0sL0j/Image1.png
>
> 9
>---------
>9 / 9 / 9
>
>or (for Brian Gaff) a fraction whose numerator is 9 and whose denominator
>is 9 division-sign 9 division-sign 9
>
>Three possible answers are given: 1, 9, 81
>
>
>My understanding is that the denominator 9 / 9 / 9 is *defined* to be
>parsed from left to right because both operators are the same, and
>therefore it is parsed as (9/9)/9 = 1/9 rather than 9/(9/9) = 9. And hence
>the value of the overall expression is 9 / (1/9) = 81.
>
>
>But is there an online source which supports the left-to-right order of
>parsing? Is it more of a common convention than a there-is-only-one-
>answer rule?
>
>
>It's one of those things that probably wouldn't arise in practice because if
>there was the slightest chance that it could be parsed in different ways,
>you'd use explicit brackets to remove any doubt and to force the answer
>that you want, but that would take the fun out of these Facebook
>"puzzles" ;-)

SMath Studio says 1

divide top and bottom by 9( iff 9 ne 0 )

1
------
1/9/9

the denominator reduces to

9/9 =1 because dividing a denominator by a number is the same as
multiplying the numerator

1/1 = 1

9
---------
9*9^-1*9 =1 someone will say ah but that's 3.8742*10^8

general case

f(x) = x/x/x/x

simplifies to x iff x ne 0

Brian
--
Brian Howie

On 2024-05-03 18:17, brian wrote:
> In message <l9h2f0Fk5e3U1@mid.individual.net>, nib <news@caffnib.co.uk>
> writes
>> On 2024-05-02 03:34, Paul wrote:
>>> On 5/1/2024 7:50 PM, NY wrote:
>>>> On 02/05/2024 00:05, Paul wrote:
>>>>
>>>> Apart from the fact that "9 / 9 / 9 / 9" isn't the same as the
>>>> question uses (*), this proves the point: it evaluates "9 / 9 / 9"
>>>> as 0.111111 or 1/9, and then if you do the initial 9 / 0.111111111
>>>> division *last* instead of first, then the overall answer would be 81.
>>>>
>>>> (*) The long line of a numerator / denominator fraction is executed
>>>> last, not first, so you fully evaluate the numerator and the
>>>> denominator, then evaluate the fraction.
>>>>
>>>  I see that providing the program, was unintentionally a good idea.
>>>  As a thought experiment, pick up your calculator.
>>>  How many division symbols are on it ?  [one]
>>>  Does the calculator have a "long horizontal line" and a "regular
>>> division" symbol ? [no]
>>>  There is no instantiation of a long horizontal line with magic
>>> properties, on computers.
>>
>> Not quite always! On my Casio fx-991EX I can do this:
>>
>> https://drive.google.com/file/d/1iYFBZHodWZjA6fza2I0wgMbn1T0wZf-R/view?u
>> sp=sharing
>>
>> nib
>
> Reverse Polish gives 1
>
> there are 3 operators and 4 numbers
>
> 9 enter 9  enter 9 enter 9 enter div div div
>
> Or maybe my calculator is totally Hewlett.
>
> The long line is an implied parenthesis (magical property),so  the
> answer is 81
>
> Compare
>
>      9
> -----------
> 1+1+1
>
> Enuf  arith for the day.
>
> Brian
>

That's exactly what the Casios do.

When you create the template for entering a fraction it effectively creates

( xxx ) / ( yyy )

which displays as the long line with holding marks above and below and
then fills in xxx and yyy as two separate expressions as you edit them.

nib

In message <l9h2f0Fk5e3U1@mid.individual.net>, nib <news@caffnib.co.uk>
writes
>On 2024-05-02 03:34, Paul wrote:
>> On 5/1/2024 7:50 PM, NY wrote:
>>> On 02/05/2024 00:05, Paul wrote:
>>>
>>> Apart from the fact that "9 / 9 / 9 / 9" isn't the same as the
>>>question uses (*), this proves the point: it evaluates "9 / 9 / 9" as
>>>0.111111 or 1/9, and then if you do the initial 9 / 0.111111111
>>>division *last* instead of first, then the overall answer would be 81.
>>>
>>> (*) The long line of a numerator / denominator fraction is executed
>>>last, not first, so you fully evaluate the numerator and the
>>>denominator, then evaluate the fraction.
>>>
>> I see that providing the program, was unintentionally a good idea.
>> As a thought experiment, pick up your calculator.
>> How many division symbols are on it ? [one]
>> Does the calculator have a "long horizontal line" and a "regular
>>division" symbol ? [no]
>> There is no instantiation of a long horizontal line with magic
>>properties, on computers.
>
>Not quite always! On my Casio fx-991EX I can do this:
>
>https://drive.google.com/file/d/1iYFBZHodWZjA6fza2I0wgMbn1T0wZf-R/view?u
>sp=sharing
>
>nib

Reverse Polish gives 1

there are 3 operators and 4 numbers

9 enter 9 enter 9 enter 9 enter div div div

Or maybe my calculator is totally Hewlett.

The long line is an implied parenthesis (magical property),so the
answer is 81

Compare

9
-----------
1+1+1

Enuf arith for the day.

Brian

--
Brian Howie