Printable View
Hello,
I'm just trying to cheat here with my homework.
I need to find the lowest number of a group of 5 numbers, entered by the user.
I also need to save all 5 numbers. So, I think it would be a function that somehow loops through each number and compares it to each other to determine the lowest one. I just can't think of how to write it.
Thanks in advance.
-Zach
well your being honest.. however this board isnt for 'cheating.' i will give a hint though:
lets say i have a list (an array if you will) of 5 'random' numbers: 5, 3, 7, 2, 9. i will try to find the smallest one:
1) what is the smallest of 5 and 3? 3.
2) what is the smallest of 3 and 7? 3.
3) what is the smallest of 3 and 2? 2.
4) what is the smallest of 2 and 9? 2.
since ive gone through the list, the smallest of all of them is 2.
hope it helps
I would guess that if you wrote out your idea more carefully, you'd be a lot farther along. (For instance, "loops through each number" makes no sense; and even if it did, once we have one number, "comparing it to each other" wouldn't make a lot of sense either.)
Sit down with a, b, c, d, and e and figure out what comparisons you want to make. Then figure out how to make those comparisons.
You could use the std::min() function, but I doubt that's what your teacher is looking for. :p
More like std::min_element, which works on a range.
But yes, you are probably expected to come up with an algorithm rather than use an implemented generic algorithm. Think about it: with an array or some other sequential container, to find the lowest, you do not need to compare each number to every other number. You only need to compare the next number with the currently known lowest. When there are no more numbers left to compare, the currently known lowest must be the lowest of them all.
Oops.Quote:
Originally Posted by laserlight
Yeah, what she said. ;)
Can I cheat on my homework. I have a cabinet due in woodshop tomorrow... Just kidding. I do applaud honesty.
Yeah, I figured that one out about 5 minutes after writing to here for some help.. (usually happens that way)Quote:
Originally Posted by nadroj
I *was* looking for a more 'elegant' way of doing it, lest I had 300 numbers instead of just 5.. but we haven't gotten into arrays yet, so maybe thats when I'll find the real stuff.. ;)
thanks to everyone who contributed.
It's not cheating if I don't get caught. ;)
-Zach
Yep, I had one like that too.. in which you need to find the lowest number entered, but that was WITHOUT having to save the entered numbers as variables, so you could just say "if this next number is lower than the first number then save it as lowNumber..) etc etc.. and at the end you have the lowest number. The trick to that was that you can actually run a test on declared variables before they even contain anything.. (took me a while to figure that out..)Quote:
Originally Posted by laserlight
We haven't started into arrays yet, thats next chapter. Whoo hoo..
-Zach
Uh, no you can't. A good compiler should warn you about it, and you produce undefined behaviour.Quote:
The trick to that was that you can actually run a test on declared variables before they even contain anything..
What you need to learn is pseudo code and flow charts. It's amazing how many people don't learn them these days and get stuck all the time because they don't.
Zach, i doubt you will be able to come up with any more 'elegant' algorithm for that, for the assignment/course you are doing. so dont think of it as 'not elegant'. the algorithm is O(n) that is it runs it linear time. i imagine any faster algorithms for finding a min are quite a bit more complex, and not what your professor/teacher is looking for at this level.
There is no better complexity than O(n) for finding the minimum of an unsorted range. That would be a logical impossibility.
you mean there isnt one yet!
...Because you aim to disprove a mathematical proof or because you refuse to accept them?Quote:
Originally Posted by nadroj
ive never studied or heard of the proof for that. not that i dont believe there is one, ive just never heard mention of it before. do you have a link to one? preferably not in form of a thesis.
Just think of it with pure logic. Take a pile of puzzle pieces (preferably a small one since this is a simple concept). Don't try to put it together, but instead just consider what the maximum speed you could possibly put it together.
You will need to do the following:
1) Have something to put together.
2) Identify the existance of each individual piece.
3) Arrange the individual piece into the larger collection.
4) Go to the next piece until the operation is complete.
Now, if you tell a computer to do the same, it will follow similar logic, right? Unless there is some sort of predefined pattern to the puzzle pieces (or a bunch of them fell out of the box already put together) then you have no way of short cutting this system. What makes you assume your program can do otherwise?
I always liked this explanation (it was for sorting algorithms, but it works here too):
Say you have compared all of the numbers in a set except for one with each other and found their minimum. How can you know whether this number is in fact the minimum without checking if it is less than the last number?
So in other words, you can't get any better than n-1 comparisons, which is O(n). (You have to look at every number in order to find the lowest in the bunch.)
. . . or something like that. Knuth said it better.
i never said anything about a program, let alone a program i made.
i dont understand how your analogy is to explain the proof. a funny thing about logic (in the sense your talking about) is that it is ambiguous and discussions can be made about the smallest topic that go on forever. i have read pseudocode and proofs that prove an algorithms complexity using only mathematics (and basic english terms, not 'logic' though). i am interested in seeing the (mathematical) proof that you mentioned. also if a sorting algorithm (which i think the best today are O(n*log(n)) are possible to be improved significantly, ie better than O(n), then you could use that algorithm and take the first element of that list (which would be O(1)) and have that the same complexity for a min algorithm as the sorting algorithm.
Why not read my post? It's not exactly a proof, but I'm sure you can find something like that if you google around. Or, if you have Knuth's book on sorting algorithms, you can look it up in there. It's near the beginning. Right where he describes the classes of sorting algorithms, and asks that you inform him immediately if you discover a new super-sort. ;)
In what way was what me and nadroj too convoluted for you to understand? Since you must identify ALL components of whatever you are sorting, you can at best only be as fast as looking at each item once. If you do not look at all elements of whatever it is that you are sorting, you potentially leave something unsorted. So your best case sort in sorting is to more or less proof read something that is already sorted and just look at each piece and acknowledge that it is sorted (i.e. a function that doesn't even really do anything other than read pre-sorted data).
What is debateable is what can most rapidly confirm that the data is already sorted. You have the web at your access to my friend. I am not going to search stuff you are capable of looking up on your own. You were given satisfactory explanation to the logic. Even if you have multiple CPU's each reading part of a pile of data, there is always going to be a point where things are only processed on an individual basis. No matter what. I applaud that you are so boldy trying to make something "better."
dwks, my reply was to master5001, i never said anything about you. also, after i posted your post didnt show up until after i refreshed.
i realize that this sort of thing is logical and only makes sense that you would have to look at each number (otherwise you could be missing the actual min, etc).
the super-sort, is that the paragraph before or after the "typo $1 cheque" thing? (or was that Dijkstra). anyways, Knuth's collection scares me!
Given your reply, and your understanding of the process and dwks' alternative explanation then I think we are good.
ya, in what way was what me and master said too convoluted for you? :p
well you are correct in that i do have the web to access. i only figured that since you mentioned the mathematical proof in your post that i was interested in seeing it. im not asking you to go find it for me, and im not going to look anyways, but it just made it seem that you had it available.
I know, I could tell by the time you posted and the length of your post. That's why I suggested you read it. Sorry if I came across as implying you had ignored my post and skipped over it. :) [edit] That's what just happened to this post, too. [/edit]Quote:
dwks, my reply was to master5001, i never said anything about you. also, after i posted your post didnt show up until after i refreshed.
I don't remember. I think Knuth has something like that: you know, offering $1 in whatever year for the first error discovered in his book, $2 the second year, $4 the third, etc. You could probably make a small fortune by now if you managed to actually find an error in one. :PQuote:
the super-sort, is that the paragraph before or after the "typo $1 cheque" thing? (or was that Dijkstra). anyways, Knuth's collection scares me!
hes going in powers of 2? wow.. i thought it was constant $1 USD.
but thats ok.. it did seem like you were being smart and saying "well why not read MYpost then, smrtas?"
Yeah, I'm pretty sure it's powers of two.
[edit] I guess it's powers of two, but actually cents, not dollars.
http://www-cs-faculty.stanford.edu/~knuth/books.html [/edit]Quote:
You are entitled to a reward of at least $2.56 if you are the first person to report a bona-fide error not on those lists. Each page tells you how to report an error for the book in question.
I guess I didn't put enough s:)m:)i:)l:)i:)e:)s in. :D
lol, cheers
End note: actually, it's $2.56 for one error, $5.12 for the next, and so on. Not by year, by error number.
http://www.upto11.net/generic_wiki.p...h_reward_check
http://www.nationmaster.com/encyclop...h-reward-check
For a list that contains unordered numbers, there is no other way than to compare every single item. Obviously, if you have a sorted list, you can find things in it much quicker. Unfortunately, it take more than O(n) to sort the list, so there's no gain in that for a single find. (And you can do "max and min" in O(n) as well - because you just check for both largest and smallest on every item, and that is also O(n)).Quote:
Originally Posted by nadroj
--
Mats
Also, the best complexity to detect if something is sorted is O(n). It's a single pass through the list, making sure that every element has the correct order in respect to its predecessor. Again, it cannot possibly be faster, because you have to look at each element at least once.
Multiprocessing or multithreading will not change the fundamentals of the O(...) method of describing the complexity of an algorithm - it will just [potentially, assuming it's actually possible to parallelise the algorithm] speed up the actual execution, which is still proportional to the number of elements in some way. If it's O(n), then twice as many elements will take twice the amount of time. If you have four processors, it will still take twice as long to do double the number of elements.Quote:
Originally Posted by master5001
That was my point. The complexity of the problem is a constant. Thus, there is no suitable way of reducing the absolute best case scenario. Which was my entire point to begin with. I am just not entirely sure where there is any room for cutting corners short of actually not checking every element.
If you didn't need to have everything sorted, you could theoretically make something with a O(n/x) complexity where x denotes a constant factor in which you skip elements of the data. The objective would simply be to sort data based on probability and skip elements that are in all probability already sorted. However, again, if something is truly randomized the probability of any element being sorted already is low.
In otherwords, you can make something with less than O(n) complexity if it does a half-assed job of sorting the data.