Calculate Scrabble Score of Word
Inputs:
Str1
Output:
Score in Ans


Code:

Decimal to Binary
Input: N = decimal
Output: Ans = 8-bit binary


Code:


I can maybe optimize it even more

EDIT:
Convert Decimal to base <= 10
Inputs: N = decimal
A = base
Output: Ans = 8-bit base-A


Code:

Is the title of this thread supposed to say "Userful" or is that a typo on "Useful?"

I was looking at this to make a little evil number checker, which requires the integer to be expressed in binary. I noticed the first routine could be changed up a little to accomodate integers of any number of bits like this:

Input: N = decimal
Output: Ans = X-bit binary (as many bits as it needs)

Code:

and since I know logBASE is not available on older calcs, it can of course be done like this as well:

Code:

Just thought this might be and interesting routine to drop here
For example, if N is chosen to be 255, the routine will output {1,1,1,1,1,1,1,1} (8 bits), but if it is chosen to be 256, it will output {1,0,0,0,0,0,0,0,0} (9 bits)

Code:


A short version of the game MasterMind.

Basically, you have to guess a four-digit code.

Code:

It generates a random code and stores it in L1.

Code:

You input your guess as a four-digit number.

Code:

This line parses your answer, turning a four-digit number into a list and storing it to L2.

Code:

This section compares your guess to the correct answer, and gives two numbers: (1) number of digits that are correct and in the wrong place, and (2) number of digits that are correct and in the right place.

Code:

I wonder how many people fainted at this infamous command. It seemed easier than the For( loop.

Hmmm I see this is some sort of guessing game with 4 integers that you must guess in 15 or less guesses aided by the output of a list of two integers (which I have yet to understand the meaning of) after every input. This is a pretty thick routine, almost looks like it's been golfed. Could you please include a description of what this routine does exactly in your post and maybe a brief explanation of how it works?

I believe there are two bugs in this Mastermind routine. The first is minor: While max(Ans will immediately end the game as a win for the player if 0000 happens to be generated. This is fixed with a change to Repeat not(max(Ans. Secondly, this snippet:

Code:

returns 2 when the code is 0011 and the guess is 1222; if we're going by the Mastermind rules I found on Wikipedia, I believe it should return 1. Here's my attempt:

Code:


That said, the routine is well-optimized. I did find a few improvements.


Code:


If it were necessary to preserve Ans, 1+4max(Ans) could have been 5^max(Ans). Two more bytes can be saved by using custom list names.

I haven't tested this yet, so it may be wrong.

That is not the best way to do it...

Code:

This doesn't seem to be posted here already and it came up over on TI|BD. Lirtosiast found this a while back. Truly amazing.
Code:


prgmA and prgmB need to be unarchived. Running prgmA unarchives, runs, and re-archives prgmC. prgmA works like the home screen and prgmC is a normal program. More info here

The End isn't necessary; as far as I know prgmC has no requirements.

After that I found a somewhat convoluted way to archive and unarchive a program using only one other program:

I think I found a bug in the Base N to Base M converter. I plug in a number and if it's less than variable M, then it ERROR: INCREMENTS. This line errors:

Code:

If the input in Str1 is equal to M, then the program outputs 1 instead of 10. The numbers 3, 7, 9, 14, 19, 22, 26, 30, 33, and 34 in this case create a never ending loop with the while loop; this is using the input base as any base. It also lets you go past base 36, stored in M (If you store it in N, it gives INVALID DIMENSION like it's supposed to), which I don't understand.
How can this be fixed?

An update to an older post:


Code:


This draws from -2 to 2 on the x-axis, and 0 to 2 on the y.

I made my own version a long time ago.


Code:

remainder() is not faster?

That routine is from 2006... There was no remainder() command. Also, the speed difference is surely negligible.



That's a lot of 1s... You could rearrange the letters to group them together.


Code:

So I was mathing yesterday and made a thing...

Riemann Zeta Function
Input: Ans = {x∈ ℝ| x≠1}
Output: Ans = ζ(Ans)

Code:


This actually converges much faster than the usual , which converges slower and slower as you obtain more decimal places. As a comparison, I tried this:
, which resulted in a 30 second calculation that was accurate to 6 decimal places.
Then I tried plugging 3 into the routine above, and got a 4 second calculation with all 9 displayed digits being accurate.

As we discussed on SAX this won't work well for negative X due to precision issues.

In 2008, trichoplax wrote this routine for Riemann Zeta of complex numbers which I'll link to when I can find it again. I don't completely understand how it works, but it runs in ~1 second for N=17, Z=3+0i at 15MHz.

Z is the argument; N is the accuracy parameter. Sublinear convergence though not as bad as summing the series directly, and it also doesn't work well for Re(Z) < 0.



Even better, all except the last line can be precomputed. So for one second of precomputation of the 20 coefficients, any number of zeta evaluations can be performed for ~0.1s each.

Sacrificing a little bit of speed, what about this routine for Scrabble score of a word?
Code:

Or this?
Code:

11 years ago, thornahawk μολών λαβέ posted this gamma function routine.
As you may know, the gamma function can be used to compute the Beta function using this form: . Therefore, you can modify the gamma function routine to compute like this:

Code:

τ.

I even took a look at the Lanczos approximation, the actual place that first guy got the gamma function formula, and guess what it consists of?


where


One more image from the Mathworld page on it:


All 2πs. No πs.