Advice from Dr. Love

[Nadian]

Shigeru Kobayashi

I need advice with some problems I've been having in school, but I'll be posting in white because it's kind of embarrassing.

>I don't know how to do long division<

Please help me Dr. Love! gonk I don't know who else to go to!

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile  

[Xarrel]

Nadian

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile

Surprisingly enough.. I understood about 90% of that...
(Sorry about humoungous quote... I tried my best to squish it...)  

[Nadian]

Xarrel

Nadian

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile

Surprisingly enough.. I understood about 90% of that...
(Sorry about humoungous quote... I tried my best to squish it...)

Well that's good. These sorts of thoughts apply pretty well to doing this sort of math in binary, which naturally helps with understanding some aspects of Computer Science. smile

But, for you other people, let me summarize real quickly what I said above:

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile  

[Redire]

summarized as a whole:

Nadian

Xarrel

Nadian

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile

Surprisingly enough.. I understood about 90% of that...
(Sorry about humoungous quote... I tried my best to squish it...)

Well that's good. These sorts of thoughts apply pretty well to doing this sort of math in binary, which naturally helps with understanding some aspects of Computer Science. smile

But, for you other people, let me summarize real quickly what I said above:

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile

pointlessness… sweatdrop  

[beaulolais]

hi.

i was engaged twice,

the first guy died.

no its not a joke.

the second guy dumped mu for a blonde bimbo where he works.

so, what's wrong with me?

or should i just give up.  

[Nadian]

beaulolais

hi.

i was engaged twice,

the first guy died.

no its not a joke.

the second guy dumped mu for a blonde bimbo where he works.

so, what's wrong with me?

or should i just give up.

Well, unless you're the one who killed the first one, I only see one failed relationship. Hardly a losing streak.  

[Shigeru Kobayashi]

Nadian

Shigeru Kobayashi

I need advice with some problems I've been having in school, but I'll be posting in white because it's kind of embarrassing.

>I don't know how to do long division<

Please help me Dr. Love! gonk I don't know who else to go to!

Words.

Best summary ever.

Thanks.

Though I'll doubt I'll ever use Long Division seeing as I'm no longer in 5th grade. In fact, no longer in elementary school. Secondary school, where the teachers don't care. =D

P.S. This started as a joke. Surprised you went full scale on helping.  

[phoenixdown919]

vampiricqueen95

ok well here it is

>ok uh, what do i do if i want to go out with my EX while i have a current boyfriend and want to go out with both but don't want to cheat on them and don't want to hurt anyones fellings?<

PLZ if you can help

Ok, in answer to that, what you need to do, is to just decide who you really love, and tell the other one they're not for you. That way, you can break up without alot of hurt feelings  

[phoenixdown919]

beaulolais

hi.

i was engaged twice,

the first guy died.

no its not a joke.

the second guy dumped mu for a blonde bimbo where he works.

so, what's wrong with me?

or should i just give up.

I think, it's not you, it's the people you were with. What you need to do, is to find someone who loves you and will not, I repeat, NOT break up with you no matter what.  

[locke317]

Nadian

Xarrel

Nadian

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile

Surprisingly enough.. I understood about 90% of that...
(Sorry about humoungous quote... I tried my best to squish it...)

Well that's good. These sorts of thoughts apply pretty well to doing this sort of math in binary, which naturally helps with understanding some aspects of Computer Science. smile

But, for you other people, let me summarize real quickly what I said above:

Long division is an attempt to do division quick, in a way similar to a multiplication strategy, but just like the binary equivalents it's a bit more complicated.

Basically, When you multiply two big numbers:

12345 x 67

One way you're taught to do this is to multiply by 7, then by 6, then adding the results together with the 6 one digit to the left. In actuality, you are rewriting the problem so that you don't have to do a bunch of addition:

12345 x 67
12345 x (60 + 7)
(12345 x 60) + (12345 x 7)
(12345 x 6) x 10 + (12345 x 7) x 1

Going even further, the way you're taught to multiply a bigger number by a small digit is an attempt to reduce the number of additions you need to do:

12345 x 6
(10000 + 2000 + 300 + 40 + 5) x 6
10000 x 6 + 2000 x 6 + 300 x 6 + 40 x 6 + 5 x 6
(1 x 6) x 10000 + (2 x 6) x 1000 + (3 x 6) x 100 + (4 x 6) x 10 + (5 x 6) x 1

Thus reducing the problem of multiplication from "add 67 "12345"s together" to "memorize 1-digit multiplication and add 20 numbers together, most of which will be really small and really simple."

A longer description, but it gets things done quicker!

So, for long division...

12345 ÷ 67

You could subtract 67 from 12345 over and over and count how many times you do that, but that would be very tedious. Instead, you can multiply 67 by certain values in order to do that quicker! In addition, you limit yourself to certain numbers so that the task is very easy!

Basically: (a number between 1 and 9) x (some power of ten)

So, if we kept multiplying 67 by 10, we'd see that 67 x 100 is less than 12345:

12345
6700

(But any bigger and it's be too big)

Then we see if we can increase the "1" in "100" (but we can't because it'd be too big.)

So, we know that at least 100 "67"s fit into 12345, but maybe there's more!

So, we've accounted for those 100 67s... now we need to subtract them out of 12345:

12345 - 67 x 100 = 12345 - 6700 = 5645

Now we're left with:

1 x 100 + (5645 ÷ 67)

We see that 67 x 10 is as big as we can get, so how much can we increase the "1" in "10" by?

67 x 2 x 10 = 1340
67 x 3 x 10 = 2010
67 x 4 x 10 = 2680
67 x 5 x 10 = 3350
67 x 6 x 10 = 4020
67 x 7 x 10 = 4690
67 x 8 x 10 = 5360
67 x 9 x 10 = 6030

We see that x9 is too big, so our number is 8! We can fit 80 "67s" in 5645. Let's subtract those 80 out...

5645 - 5360 = 645 - 360 = 285

Now what we've got is:

1 x 100 + 8 x 10 + (285 ÷ 67)

You can't multiply 67 by 10, so now you find out what the biggest 1-digit number you can multiply 67 by is! (Since I already calculated the 67 x (2 through 9) just above, I can see the biggest value is 4.)

Subtract out those 4 "67"s...

285 - 268 = 17

Now what we have is:

1 x 100 + 8 x 10 + 4 x 1 + (17 ÷ 67)

So, now we add together how many 67s we took out:

100 + 80 + 4 = 184

And our remainder is 17!


Naturally, if you didn't understand how to do long division, this probably didn't make a lick of sense. Heck, you probably need to be comfortable with algebra to understand what I was doing, maybe even why.

This is why I don't intend to be a teacher... ninja

However, I can say that all that complicated math I just mentioned... basically the way multiplication and long division are taught here, the way they have you structure them pretty much forces you to use this, helping you accomplish the arithmetic faster.



Incidently, this reminds me of my CS310 class. At the University of Texas, CS310 is supposed to help you have an abstract idea how a CPU could be designed. In this case, they take a made-up processor called the LC3, which is designed to be incredibly simple for educational purposes. The instruction set for the LC3 has only 16 commands, one of which is a "noop" (meaning it does nothing.)

Basically, because it has so few commands, there are many things that modern processors do for you that this doesn't, multiplication being an example. Heck, it doesn't even explicitly give you bit-shifting operations.

Naturally, one of the programming projects for that class was to design a function that could multiply two numbers together (in the LC3 language.) It was suggested that students go ahead and do it by the definition of multiplication: just add the second number to itself over and over, but make sure to handle negative numbers correctly.

Fortunately for me, I had gotten a couple of insights while looking at the LC3 commands and, when we first got it, I had already made a function a month before this project which did multiplication, except with bit shifting. Bit shifting to do multiplication is fast because it turns multiplication into a couple of additions using the exact strategy I mentioned at the beginning of this post (except in binary instead of our normal counting system.)

So, what I did for that project, instead, was I started optimizing my multiplication function. I also explicitly tested it to make sure that it worked on negative numbers. What fun! I ended up making it so sleek and small that it sort of stood out. Basically, the TAs / graders had an example program to compare against which used the repeatedly-add method the instructor had said people could use.

I ended up getting a question from a TA on the class newsgroup asking "are you sure your solution works? It's only 21 bytes... ours is 22..."

Heh

Naturally, full credit.

(If you're curious how I did bit-shifting without the aid of an explicit bit-shift command, I remind that a logical shift left is the same as adding a value to itself in binary, and fortunately multiplication can be done using only logical shifts left.)

Yeah, nothing earth-shattering, but I thought it was cool. smile

If I didn't already know long division, that would have been a lot harder to understand.  

[phoenixdown919]

vampiricqueen95

skinEmon

vampiricqueen95

ok well here it is

>ok uh, what do i do if i want to go out with my EX while i have a current boyfriend and want to go out with both but don't want to cheat on them and don't want to hurt anyones fellings?<

PLZ if you can help

Ok, in answer to that, what you need to do, is to just decide who you really love, and tell the other one they're not for you. That way, you can break up without alot of hurt feelings

thx but another person is actually involved

well then, i guess that could complicate things