...um, I'm not really sure what to say then. You're not really giving me enough info to help you with.

Are you sure it isn't a problem with TIConnect? Have you tried transfering other files? Have you tried transferring your program to Wabbitemu? If so, what did it do? Are you sure it's actually overwriting the old program? Try saving it under a different name and transferring?

I fixed it so that it will now the parser will ignore any characters it doesn't recognize instead of just hanging there.

I don't really have time to do make an exe until the weekend though (and do some other minor fixes) so if you need an update, just download a fresh copy from the repository.

Necro, but... I can provide builds for Linux and Windows if you want. Also, can I submit patches to fix some of those issues on your bug tracker?

Sure, that would be great!

Let's see -- do I need to add you as a contributer or something so that you can submit patches? (not sure exactly how Google Code works) If so, post or PM me your email address/google account.

When using Zedd, is it the coder's responsibility to run through all the existing objects and draw/otherwise render them to the screen, or does Zedd handle that?

LoadZ(): r6 is the sprite number. What precisely is the sprite number? I looked in the source for the demo -- I'm not entirely sure how you're drawing the objects. Do all sprites have to be pointed to Str0SP, or does it not matter?

I don't own an nspire, but once when I bricked a friend's nspire (by accident, I swear!) it would only reset after I held down the reset button in the hole for like 10-15 secs. Pressing briefly didn't seem to trigger the full reset.

Apart from programming on-calc (Axe, TI-Basic, etc.), I use mostly tools I made/helped make on the computer.

For my IDE, I use a combination of Croquette to convert text files to .8xp and gedit as my primary editor (with a custom syntax-highlighting plugin I made).

I use Wabbitemu/wxWabbitemu to make screenshots or compile+test Axe programs on my calc.

I've actually ended up using Gedit for most of the coding I do (on Linux) -- it has syntax highlighting, which is all really need

@Darl, Michael Why not give me the logo code, I'll try it on my calculator

It might need some editing, but here you go: I don't trust myself atm to make any changes to the code, so I just added comments. Also, I think the trig functions take in radians in Python, but I liked degrees, so I have sort of a conversion thing going on in there.

def drawTriNum(side_length, tilt=60, distance=10, dot_size=5, write_total=True): """Draws a triangular number (1, 3, 6, 10, etc...)

side_length = the length of a single side. 1 -> Triangle with area of 1 2 -> Triangle with area of 3 3 -> Triangle with area of 6 tilt = The way the triangle is angled. distance = The distance (in pixels) between each dot dot_size = The size of each dot (in pixels) write_total = Disregard this, don't bother translating. """

total_dots = 0 for i in range(side_length): setheading(tilt) for j in range(i): forward(distance) setheading(0) for k in range(side_length - i): dot(dot_size, "black") total_dots += 1 forward(distance) goto(start_position)

# Don't bother translating anything from here to the Return. if write_total: goto(start_position) setheading(0) forward((side_length - 1) * distance / 2 + 1) setheading(270) forward(30) write(str(total_dots), move=False, align="center", font=("Times New Roman", 12, "normal")) goto(start_position) setheading(start_heading) tracer(True) return total_dots

def drawStellarFigure(vertex_num, shell_num, warp=1, distance=10, dot_size=5, write_total=True): """Draws a stellar figure (like a star).

vertex_num = the number of vertexes shell_num = how many layers there are warp = The higher the warp, the more angular the figure. distance = Sort of like the distance between dots dot_size = The size of each dot (in pixels) """ shell_num -= 1 start_position = position() start_heading = heading() penup() tracer(False)

dot(dot_size, "black") total_dots = 1

shell = [] for i in range(shell_num): for j in range(vertex_num): for k in range(2): if k: forward(distance * (i + 1) * warp) else: forward(distance * (i + 1)) dot(dot_size, "black") temp1 = radians(180/vertex_num) temp2 = acos(sin(temp1/warp)) right(90 - degrees(temp2) + 180/vertex_num) total_dots += 1 shell.append(position()) goto(start_position) setheading(start_heading - 360/vertex_num*(j+1)) goto(shell[-1]) pendown() for pos in shell: goto(pos) penup() goto(start_position) setheading(start_heading) shell = []

# Don't translate this 'if' statement if write_total: forward(distance * (shell_num + 3)) setheading(0) forward(1) write(str(total_dots), move=False, align="center", font=("Times New Roman", 12, "normal")) goto(start_position) setheading(start_heading) tracer(True) return total_dots

if __name__ == "__main__": main() mainloop() # This runs the actual program

I once had a large math paper and used the Turtle module in Python (which is pretty much a copy of Logo) to construct a bunch of pictures/geometric shapes for it. I was the envy of my math class

How many five digit integers satisfy the following: - All the digits are odd - The difference between adjacent digits is 2 An example of such a number is 13535 or 57979

...and wanted to generalize it to "How many answers satisfy the conditions for n-digits"?

For example, given one digit, there are 5 possibilities {1, 3, 5, 7, 9}... and given two digits, there are 8 possibilities {13, 31, 35, 53, 57, 75, 79, 97}, etc.

I managed to figure out a solution that didn't involve drawing out ridiculously large probability trees to brute-force the answer, but I want to know if there's an algorithmic or better way to solve the problem.

Here's my solution below (it's an exact copy of an email I sent to my teammates), but I don't really understand why my solution works. (spoiler'd for length).

Spoiler For Spoiler:

So, I was puttering around with Python, trying to find patterns in the problem, and hit upon a method for finding the answer. The only thing is, I have no clue how it works. It's also kind of difficult to explain without using paper + pencil (or whiteboard + marker, which is much cooler), but I gave it my best shot.

(If possible, view this email in a monospace font -- try copying and pasting into notepad)

* * *

In short, If the answer has one digit, then there are 5 possibilities 1 + 1 + 1 + 1 + 1 = 5

If the answer has two digits, then there are 8 possibilities 1 + 2 + 2 + 2 + 1 = 8

If the answer has three digits, then there are 14 possibilities 2 + 3 + 4 + 3 + 2 = 14

If you notice, each number in the sequence is equal to the sum of numbers that are to the left to the right on the row above it.

3 6 6 6 3 \ / 6 9 12 9 6

(9 is the sum of 3 and 6, for example)

So basically, this is like Pascal's triangle, except it's more a rectangle with some fiddly bits.

* * *

If you're wondering what the numbers represent, they equal the number of possibilities each branch in the tree has or the count of the number in the final branch of the tree (that didn't make sense, did it).

Each layer represents the number of possibilities in the tree. If there is only one digit, there's only 1 1 1 1 1 possibilities.

If there are two digits, there's 1 2 2 2 1 possibilities per branch. However, there is exactly 1 one 2 threes 2 fives 2 sevens and 1 nine given two digits.

If there are three digits, there are 2 3 4 3 2 possibilities per branch. However, there's 1 one 3 threes 4 fives 3 sevens and 1 nine in that layer.

...to be honest, I need to start doing that myself.

yes, I've been waiting for Lights and Axe Minewseeper 1.00 for over a year now.

<.< >.> <.<

Shhhhhhhhh....

Another tip: don't be recklessly overconfident and be like "oh, I can completely rewrite a game it took me several months to make from scratch because I'm so much smarter now!" (lesson learned)