Oops, I just noticed a fatal mistake with my optimization to Lbl ABC; I forgot to add 'A' to the random result to actually make the random result in the range of letters! I fixed it now, so if you already grabbed that code, you should grab the fixed version.

I lied, Link's Awakening shifts 4 pixels at a time, not 8. But it doesn't really matter what amount he shifts by in the end as long as the transition isn't too fast or too slow.

Alternatively, here's an even smaller method that might qualify as "cheating." selectcoaxial mentioned in his first post that finding the matrix of minors is part of the algorithm to find the inverse of a matrix. But the calculator already has a matrix inverse function. So instead of going forwards in the algorithm from the input matrix, let's go backwards in the algorithm from the inverted matrix!

After trying a few layouts, I've settled on this program, weighing in at a petite 45 44 bytes!

Prompt [A]
min(dim([A]→A
identity(A
For(B,2,A,2
*row(⁻1,Ans,B
End
Ans([A]⁻¹Ans)ᵀdet([A]


EDIT: My TI-Basic optimizing skills are a little rusty, so I didn't notice that I could optimize a parenthesis off the last line until now. This makes the size of the code 44 bytes. I won't bother to re-upload the 8xp, it's only a small change.

The Freq() command takes two arguments: wavelength and time. TBO_Yeong and linuxgeek96, I'm not sure where you got your wavelength numbers from, but neither of them appear to be correct. The approximate value that I got was 487, using this formula for the wavelength argument with middle C's frequency, 261.63Hz:

Wavelength argument = (6000000/frequency - 62)/47

---

Now, to deal with the time argument. The formula for this is a little more complex, since it doesn't have an explicit form, only implicit:

Desired duration = (47*time argument + 48*floor(time argument/wavelength argument) + 71)/6000000

However, if we give floor(time argument/wavelength argument) an approximate constant value instead (I'll give it about 50), we can get an explicit form:

Time argument = (6000000/desired duration - 2500)/47

If we wanted a note length of 1/4 of a second, this would give us a time argument of approximately 31900.

---

Putting it all together, to play middle C for about 1/4 of a second, you would use the following code: Freq(487,31900).

In the current state of Axe, I agree, the input comamnd is a little lacking in terms of supporting commands. It returns a string of tokens, but there are no Axe commands to handle strings of tokens...


However, you can always make your own. Here's a routine I whipped up to return 1 if a token pointed to is a 2-byte token, or 0 if it's a 1-byte token.

.INPUT=pointer to token
Lbl Is2B
Return inData({},[BB5C5D5E606162637EAAEF00])+255/256

You could then call this routine from another routine, like this routine I wrote to print a length-prefixed string of tokens (that's what the input command returns) to the screen/buffer:

.INPUT=pointer to first token
Lbl Print
→r₁+{-2}ʳ→r₂
Lbl PL
Return!If -r₁
Text Select(r₁,+Is2B()+1→r₁)►Tok
r₂:Goto PL


If it's only four numbers, the fastest way would be a couple of nested min() commands, like this.

min(min(A-1,B-1),min(C-1,D-1))+1

EDIT: Actually, I'm not entirely sure if this will work how you want it to. It depends whether or not you want 0 as a result if two or more of the values are 0. For instance, if the numbers were 0, 0, 1, 2, this routine would return 1.

Regex'd in all the commands, fixed some bad numbers, added graph formatting commands, and converted into an 8xp. It's all set to try.


EDIT: For those who would just like to see the screenshot: