[Any] A quick speed tip

[Miguel]

If you like making fast programs (I know I do!) one thing to consider (that is often overlooked) is looping.

I'm not saying looping is slow, in cases it's needed, but take this code for example (C++):

vector<string> myvector;

// ....

for(int i = 0; i < myvector.size(); i++){
    // do stuff...
}

Notice where in the loop, you are calculating the size. In a looping structure such as this, the computer will be calculating the terminating condition (in this case i < myvector.size() ) every time the loop iterates. Though not major with smaller lists, in programs where you have a large list to process (that doesn't get modified as the loop is running), this can quickly add up.

More calculations = less speed = more space needed to store the calculation = more heat generated inside the computer = CAN SUCK MAJORLY

Easy way to speed up, save space, the environment, etc: create a variable to hold the size. In most languages depending on the structure a size() or count() operation can cost O(n), and running something that slow many times as you iterate through a list sucks.

vector<string> myvector;

// ....

int vsize = myvector.size();

for(int i = 0; i < vsize; i++){
    // do stuff...
}

[Reemer]

Makes sense, but I never thought of this before! If you're only doing the myvector.size() for one operation, say if the loop only went once, would it be more efficient?

[Miguel]

Makes sense, but I never thought of this before! If you're only doing the myvector.size() for one operation, say if the loop only went once, would it be more efficient?

Well if the loop is only going once, then I don't see why you're using a loop in the first place

[Jehuty]

Makes sense, but I never thought of this before! If you're only doing the myvector.size() for one operation, say if the loop only went once, would it be more efficient?

It'd be roughly the same time considering it's doing the exact same number of calculations. I mean, the time it takes the compiler to declare and set an additional variable is barely measurable.

Also, not a bad tip, but I'm fairly confident that some modern languages are actually smart enough to take care of this for you.

[bamag]

I don't think it would be that much of an improvement. Both ways of doing the loop would be O(n) efficiency. Sure it'll be slightly faster, but it would probably be unnoticeable. Also this would not apply if the size() thing changed values. And jeez, C++ looks so similar to Java :o

[Miguel]

Languages such as VB6 don't do this for you, which is annoying, especially dealing with larger arrays/lists and knowing that VB is already slow.

I don't think it would be that much of an improvement. Both ways of doing the loop would be O(n) efficiency. Sure it'll be slightly faster, but it would probably be unnoticeable. Also this would not apply if the size() thing changed values. And jeez, C++ looks so similar to Java :o

I mentioned that it wouldn't apply if the size didn't change values.

[bamag]

Languages such as VB6 don't do this for you, which is annoying, especially dealing with larger arrays/lists and knowing that VB is already slow.




I mentioned that it wouldn't apply if the size didn't change values.

Hmm, I don't see it in your post but okay :p
But I guess your tip is somewhat useful as it can reduce something that could take 2n steps to n+1.
By the way, are you in college or high school? I thought you were older but your thread about physics made me consider otherwise :o

[Miguel]

College most physics courses are taken sophomore year at my school and I'm already in 4th-year CS courses

[bamag]

Cool, I'm still in high school lol. Taking Java course as a junior and going to take C as a senior
CS is probably going to be my major :p

[Miguel]

Yeah my HS didn't teach anything even related to computers, self-taught myself a lot