Project Name : prgmNUMSORT

Description : I'm looking for someone who would want to do a little coding. I want to make a program and need some help. Basically, you enter a number and it will tell you which of the following groups is falls into (Odious #'s Happy #'s Unhappy #'s Evil #'s Lucky #'s Economical #'s Wasteful #'s) Anyone reading this thread probably has no idea what those numbers are. Look them up cause that is what I did. anyways, I think to do this we have the program run the number through the bounds of the number groups and display that number group when the number falls in it. Hopefully, it is as simple as it sounds and if you want to help just reply.

Why : I compete in math competitions, and believe it or not they ask questions about what number groups a given number falls under. I also want to learn more about programming.

---------------------------------------------------------------------------------------------------------------------
Edit:
The first bit of code completed. This will knock out the Evil and Odious categories. Please Reply with improvements if you see anything that isn't very efficient. Thanks to everyone who helps me. This is a great learning opportunity.


Code:

Something like numbersaplenty.com.

Plenty of structural supports go into a program like this one. They need to be erected separately to some extent, so pick a couple that seem like easier lifting, start building those up, and if something gets snagged or misaligned along the way, describe what was being handled, where you wanted it, and point out the hitch. This helps us identify what tool(s) to lend, in lieu of offering an entire supply warehouse, which you've already got but might not know precisely what to do with.

I just finished making the second part which would detect happy and unhappy numbers but there is a mistake in it somewhere. I will post code after school.

Just wondering, what is the point behind happy and unhappy numbers? It seems a bit weird

Remember, if something in an "If" statement equals 0, use not(condition) instead of condition=0, to save a byte of memory in your program. Also, ClrList [list 1] saves 1 byte rather than 0->dim(list 1).

As i mentioned before, I am working on coding the happy and unhappy number segment of my project. A quick explanation of happy and unhappy numbers follows.

Happy/Unhappy Numbers : Take the number and find the sum of the squares of each digit. Take this sum and repeat by finding the sum of the square of the digit. If this number eventually reachs one it is happy if it doesnt reach one it is unhappy.

Examples
Happy # = 7
7^2=49
4^2+9^2=97
9^2+7^2=130
1^2+3^2+0^2=10
1^2+0^2= 1 (Remember once we hit 1 we can call the number happy)

Unhappy # = 215
Based on the definition of an unhappy number, it seems hard to know when you should stop calculating since it never reaches one. What I have noticed is when a sum of the squares repeats, we can consider the number unlucky.
2^2+1^2+5^2=30
3^2+0^2=9
9^2=81
8^2+1^2=65
6^2+5^2=61
6^2+1^2=37
3^2+7^2=58
5^2+8^2=89
8^2+9^2=145
1^2+4^2+5^2=42
4^2+2^2=20
2^2+0^2=4
4^2=16
1^2+6^2=37 (Finally we have a repeat in the number 37)

I have found a few grey areas in my code that I could use some help on. My code will be posted below and I will try to make comments so that you may follow the code easily.

Code:

(A) I don't know how to make a loop where it stops on one of the following events :
Stops when a 1 is stored in list2 or when a number is stored for the second time in list2
(B)Sums of Squares of digits stored in list2. in list 2 we are looking for repeats or the # "1"

Please help me out especially with making the loop constraints for when a number repeats or =1

Checking for 1 is easy. For repeats you have two options:

* Store all previously seen values in a list; if the new value is in the list you have a repeat. A list L2 contains a value N if max(L2=N.

* Use the Pollard cycle finding algorithm, which would be a good challenge to code. It's more complicated but only needs to store 2 values.

Thanks for the advice I will try this out. I assume you do one as follows: max(L2=1

Finished next bit of code. If anyone wants to optimize it, knock yourselves out. I appreciate everyone here.

This is all of the code merged together. This will tell you if a number is Evil Odious Happy ,and/or Unhappy


Code:

Here you go, although it only says HAPPY/UNHAPPY:


Code:


Probably could be optimized more, but meh

I had much the same! For a speed boost, one could prepare

Code:

before the input, then smartly place L₂ within the loop.

For the reveal, I used:

Code:

Note that there are two spaces at the end of the string.

If that's somehow undesirable, here's a short fix:

Code:


EDIT: Was able to shrink 1+2(Ans=1) down to int(3^Ans⁻¹) in both cases thanks to lirtosiast's light prodding, but I will leave the former up as a case study.

Thanks for all of the help, but where did the evil and odious part of the program go?

A quick explanation of evil and odious:

Odious:
When changed to binary, there is an odd number of ones.

Evil:
When changed to binary, there is an even number of ones.

Alright, then. First approach:

Code:


Which is to say:

1. Assume one answer
   
2. 1. Divide by sufficiently many powers of 2 while taking only integer parts
      
   2. Add together the parities of these (as all/most of their one-halves will cancel out)
      
   3. Ask whether there was a 0.5 left over
3. If so, switch answers
   
4. Show answer

Next up is:

Code:

This keeps on dividing by 2, switching the sign with each change of parity, then asks in the end whether it's positive or negative.

These two programs have equal footing both space-wise and speed-wise! The only issue is with the former not handling 0 correctly, which can be amended with:

Code:

I just stumbled across this Omnimaga thread which has an even more optimized TI-BASIC version of HAPPY/UNHAPPY (thanks to calc84maniac!). I'm just putting it here for your information