You know, when I'm dealing with lists, it is just a pain to go about deleting/adding elements that aren't at the end. As a genera rule when I have to do anything like this, I just put a "0" in the elements that are "deleted", and when I'm using the list, I have it go through a conditional to make sure that element isn't "0". This way, as far as the program is concerned, that element is "deleted". I just think actually deleting elements and messing with the length is unnecessarily complicated in Ti-Basic. I know that in other "real-world" programming languages it is just as simple, but I think that there is a better and easier way to do it here.

For your problem (and other similar issues) may I suggest doing stuff along these lines:

 {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1→⌊FLASH Repeat max(⌊FLASH)=0 For A,1,16 1→B If ⌊FLASH(A) prgmQUESTION //run program that asks question-"A" contains # of question B→⌊FLASH(A) //if user got question right, store "0" into B End End 

For testing purposes, here is QUESTION. I'd just put it into the above program, there really is no need to make it a subprogram here, put I don't know what you are doing.

 ClrHome Disp"" Output(1,15,A //the question number expr(sub("1111111112222222",A,1→C expr(sub("1234567891234567",A,1→D Disp "" Output(2,7,C Output(2,8,"+ = Output(2,9,D Disp "" Input "Ans?", E (E≠C+D)→B 

 Disp A, B 

 Disp A Disp B 

Well, you can't quite get exactly what you want. This is because the 83 series doesn't support symbolic expressions; stuff like this would be simple on an 89 or an Nspire. There are 3 ways to get stuff on the home screen (that i know of), each have their advantages and disadvantages.

Disp

This one is the only one that lets you give more than one argument at a time, although doing so makes no difference from seperating it out. What makes Disp unique is that it follows the rules as though you had punched it into the home screen outside of a program.

Pause

Yes, you can give pause an extra argument and it will display it to the home screen. The main reason that you would use this is because if you give it a list or matrix that is larger than the screen, it will let the user scroll it, unlike Disp and Output. Like Disp, it follows the rules as though you had punched it into the home screen outside of a program; but unlike Disp, it treats stuff that was put on the screen by output as thought it had been put there by disp.

Output

Unlike the other 2, output doesn't work on a line basis, it goes off of home screen coordinates. This can be an issue when you have numbers that could be either 1 or 2 digits.

To make it the exact way that you want it in your scenario, well I not sure how to do it. Here's what I'd do.

 Output(1,1, "A(X-D)^^2^^+E Output(2,2,"A=" Output(2,4,A Output(3,2,"D=" Output(3,4,D Output(4,2,"E=" Output(4,4,E 

This would display it on the screen like when you do a regression- equation at top, with variables written underneath. I'm thinking that even the TIOS has it this way because their operating system doesn't support symbolic expressions, and this still looks neat.

I suppose you can accomplish this by creating an auxiliary list. If the person gets the card wrong, store the card number into something like OVER2, and in the very end after all the cards have been replayed, store OVER2 into OVER and try again.

If you don't want an auxiliary list, I believe there might be a method by which to do that as well.

I leave it up to you to get the matrix elements which correspond to those rows and columns into a list (not that you can store strings to lists, but I'm sure you have a number associated with your character in the matrix).

5üZ
5üX

Disp [A](Z-3,X+1)
Pause
Disp [A](Z-3,X)
Pause
Disp [A](Z-3,X-1)
Pause
Disp [A](Z-2,X+1)
Pause
Disp [A](Z-2,X)
Pause
Disp [A](Z-2,X-1)
Pause
Disp [A](Z-1,X+1)
Pause
Disp [A](Z-1,X)
Pause
Disp [A](Z-1,X-1)
Pause
Disp [A](Z,X+1)
Pause
Disp "X"
Pause
Disp [A](Z,X-1)
Pause

that's an example to get the values on the screen, now I only have to store these numbers in a list. that's no problem.
anyway thank you for answering!

greetings

LM358

and the player ist at position X.
Then I take the area around the player. In my case it's:
011
100
0X1
and then put it into a list like that:
0X1100011

I hope you unterstand what I mean.

158
269
37a
4Xb

I know that you won't have all those characters, but this is just so that I know what you are trying to do.

greetings

LM358

greetings LM358

I think you are trying to use your newly created list in a program, but don't know how to get stuff out of the list and use it. With that "for" statement, you were trying to get the contents of the list into variables, but it doesn't do that.

I think that this may help you:

You can use any one individual element of a list like a normal letter variable. Just use ⌊OVER(X). But don't actually put "x", put the actual number of the element that you want to get out of the list.

For example:

 {1,3,5,7,9}→⌊OVER 5 →A Disp⌊OVER(3)A 

This code would display "25" because the 3rd element of the list is 5, A is 5, and 5*5=25.

I hope I was remotely helpful.

Ti-83's,Ti-83+'s,Ti-83+SE's,Ti-84+'s, and Ti-84+SE's all use nearly the exact same Ti-Basic language. The only difference that you'll run into often is that the 84's have a built in clock and functions that use it, while the 83's don't. There are a few other differences that you can check out on the compatibility page, but that's probably the only one you'll really need to know about.

On the other hand Ti-89's and Ti-Nspires's are completely different. You basically can't program Nsprires, while Ti-89's use what's known as 68k ti-basic, which is much more powerful, and much different.

Upon understanding the request, my first thought ran across an entirely different track, away from for loops. And I tested it this time.

 If max(T/6={0,1,2,3,4,5}+1/6 

@ Take_it_Slow

This works because of the way that you are allowed to mess with lists. {0,1,2,3,4,5} is an example of a list. When the calculator sees {0,1,2,3,4,5}+1/6, it adds 1/6 to each element of the list. Now it is left with T/6={1/6,7/6,13/6 etc}. Next the calculator evaluates the boolean expression for each element of the list. This leaves it with a list with 1's and 0's. Max( gives me the largest element of this list. If T/6= any element of the list, then the largest number will be 1, and thus true. If not, the list will contain nothing but 0's, and the "if" statement will return false.

I hope this makes up for my stupidity.

You may remember about this special For statement:

For(Z,1,dim(⌊OVER
⌊OVER(Z→I
In all those discussions, on the site, the line above would look like {1,3,5,7,9}→⌊OVER. I have realized that I have just lists but cannot integrate the contents of the lists so that the loop will run. All this stuff about initialization will not work because I presently do not know how to recover the contents of a list. Sure I can display a list but using it's contents, in this context, is another matter.

I apologize for not coming to this conclusion sooner and thus wasting so much of the time of sight members.

Thanks in advance.

john

EDIT:

P.S: it seems that when I want to access a matrix I enter coordinates like this: [A](y,x) that's strange

Actually, if y is the row and x is the column, then it is quite normal since Matrix dimensions are labeled by row x column. [A](1,2) means row 1, column 2.

It happens to be 6X+1 for 0≤X≤5, which can be inferred from the pattern in your first codebox and deduced immediately from the second; in other words, it's T=1 or T=7 or T=13 or T=19 or T=25 or T=31.

Instead of testing each case individually, you can use the fact that the only numbers which leave 1/6 as the fractional part are those that are one higher than multiples of six. So, take the fractional part of T divided by six and compare:

fPart(T/6)=1/6

Simplify:

6fPart(T/6)=1

Rearrange to save an extra byte:

1=6fPart(T/6

And if it must exclude any number outside of your originally stated bounds, then use a second condition:

1≤T and T≤31 and 1=6fPart(T/6

You'll find that this produces the same truth table as its ancestor.

0
For(F,0,5
Ans OR T/6=F+1/6
End
If Ans
//Condition

 For X,0,5 If(T/6=X+1/6 End 

This is known as a "For" loop, and it is your friend. :)

I'm programming a game on my TI-84 Plus, but that's the same TI-Basic I think… So, I need to feed the chars of a matrix in a list like that:
Matrix:
111
101
010
1X1

List:
11010101111

The coordinate X is the players position, and the numbers around X (like shown above) should now be read into a list.
I have no idea how to do this job. Could somebody send me a code snippet? Please send me only the short snippet, because I don't have much time because this program should be finished until tomorrow.

Thank you in anticipation!

Greetings LM358

P.S: it seems that when I want to access a matrix I enter coordinates like this: [A](y,x) that's strange,…

I'd already created the list

Say your list is named ∟LIST, the Nth element is then ∟LIST(N).

thornahawk

Store the list to L₁ or a named list, and then you can easily get the value of the nth entry.

thornahawk

E.G {1, 0, 1, 0, 0, 0, 1, 0} -How could I get the value of the 3rd entry

thornahawk

 ClrHome For(A,1,1000,2 For(B,3,A-1,2 If fPart(A/B)=0 A->B End If B=A Disp A End 

Just out of curiosity, can anyone make any improvements or is there just a much better way?

Thanks.

PS you can reply in a new thread if you want.

 seq((L₁(I-(I>A))-N)(I≠A)+N,I,1,1+dim(L₁→L₁ 

is just a little bit simpler.

:)

thornahawk

:seq(L₁(I-(I>A)),I,1,1+dim(L₁→L₁
:N→L₁(A

If you want it all on one line (this has its conveniences) you can do

:seq(L₁(I-(I>A))(I≠A)+N(I=A),I,1,1+dim(L₁→L₁

which takes 4 more bytes. However, if you plan on doing a lot of insertions into lists, you can do this:

:"seq(L₁(I-(I>X))(I≠X)+Ans(I=X),I,1,1+dim(L₁→Y₁
:N:Y₁(A→L₁
:1234:Y₁(3→L₁

I do not like single character variables, because of integration problems with other folks that are developing code that may be in conflict with what is in my program.

Can I put "{1}→∟ TIM" in the original program and use

"If TIM(1) =1" and so on the the second program?

I wanted to do

 "5"→sub(Str1,A,1 

But I had to go through the process of cutting the string, adding the character I wanted, then glueing it back together.

I actually wasn't changing "1245" into "12345", but rather "12445" into "12345", but with strings you have to do it with the cutting and gluing.

I was testing the tutorial's code, and I could tell that the collision detection would only work for up and down, but you adapted it for left and right. I was just commenting on what the tutorial provided. It really could use some work, I might get around to it soon. (the tutorial-that is, not the code).

Let's say I have {1,2,4,5} and I want 3 to be the third element, but 4 and 5 must remain. Unfortunately, the only way I know of how to do this is to separate the list and glue them together while throwing in the 3 in the correct spot.

The seq( command is good for creating a sublist (cutting the list up), and augment( will glue the lists together. So, this code will work for sure assuming the number is going between in the list:

I feel as if there is a better way to do this, though I can't think of one.

So, to solve this in the easiest fashion, you'll want some variable to be the overall variable. We'll use B since you used that in an example above. In the original program, I believe you called it OVER, put a 1→B somewhere near the beginning assuming B isn't used anywhere in the program. In REDUE, put the code:

2. Um, actually I found one a little while ago (almost). I used codex's rectangle drawing ability to replace 8 of the line commands, so that I draw 2 codex rectangles and 4 lines. This shaved quite a bit of time off of it, enough to (almost) double the prisms/second rate of my method w/ prerendering. That's nearly 10 prisms/second!!!!

3. I think that we should go either with a more limited but faster engine (my method), or a more powerful but slower engine (builderboy's rasterization).

4. Agreed, but we could use an already-built lib's rectangle drawing ability (like codex), since 8 of the lines drawn will form 2 rectangles. (at least in my method)

5. I suggest that the engine calculates, and we supply instruction on how to use variables, and (possibly) provide asm for faster drawing. This leaves the major decisions up to the individual game; like whether or not to get the variables early, and whether to use asm or not. This would allow programmers to aim for pure Ti-Basic or part asm, or provide it as a game option.

and what do you mean it might s47-s6 might screw up? is it because the key might be edited by the previous index? nope. it takes the encryption key and finds its 'opposites' (in sets of 16 bits)

and yes, this is python

 {1,2,3→L₁ and you want to add 4 so... augment(L₁,{4 this only adds 4 to the back (reverse L₁ and {4} to add to the front 

 {1,2,3,4→L₁ 

or

 use SetupEditor (i believe its in [STAT], [enter]). recall the list and go to the bottom of the list (where the '-----' is) and type in the number 

Clearer now. Timothy, You certainly have learned at a very early age, compared to mine, to ask very good questions. I certainly helps focus the discussion:-)