I was looking at the post on the front page thinking: "oh yea, I remember those games... Uncle worm, paper plane, phoenix, ... What's that last one? I remember seeing that from somewhere... OH, wait... is it? *facepalm*... "

Well I'm humbled that my modu10 game is considered a classic game that you enjoy playing many times! It was based on a flash game I found online a few years ago. According to a few reports, modu10 is only functional on older calcs. Newer versions aren't compatible with xLIB (probably bc of the firmware/os). It also only works with xLIB afaik. DoorsCS had trouble rendering the shapes last I knew.

BTW, additional levels are unlocked when you complete the first 49! (just a little easter egg)


Now, concerning this contest, I might have some free time to create something. I'd have to re-learn how Axe works. A good puzzle game would be fun...

This reminds me of an old DOS game called Word Rescue:


btw, the youtube tags don't like https links...

So, electronic music...

Some of you may have heard my music already, but here are my most recent tracks!
Enjoy!

1. Loki Stole My Headphones
2. Purple Fuzzy
3. I didn't say Stop...

I'll see if I can upload to the music topic... (4096KB not enough unless I re-sample @ 96kbps)
Download from SoundCloud!

Follow me on SoundCloud:  ---->  http://soundcloud.com/nitacku  <----

HD has better audio quality btw

May I ask what you mean by Touhou illustrations??

Touhou character illustrations. There's quite a fan base actually!

<Image Reference>
EDIT: link was broken somehow... See post below!

When I create music, I don't worry about music theory. I only focus on how it sounds. (I do happen to know music theory though )

I can offer some tips for creating music with software:

1: Create a 16 measure loop (Assuming you're using 4x4 time, 16 measures will create a complete phrase)
2: Create your bass chord progression with single notes. Think Pachelbel's Canon. The opening does exactly this.
3: Insert a new instrument. Add notes to chord progression. This would be the harp & violin you hear in the beginning of Pachelbel's Canon.
4: Flush out the chords if you want.
5: Be creative! Copy that 16 loop and tweak with the note lengths.

Eventually you will have 16 measures that you're satisfied with. This should be your chorus. The entire song focuses around this 16 measure loop. You also know what instruments you're going to use now. You can create an intro and ending by layering  instruments for example: A-> A&B -> A&B&C -> A&C -> C

I hope this helps. This is roughly the process I use when creating music.
Also, if you're not having fun, you're doing it wrong


EDIT: Pachelbel's Canon for reference

I wrote a C program to brute force the result since I'm lazy

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include "SFMT.c"

typedef struct ChangeStruct
{
int penny;
int nickel;
int dime;
int quarter;
} Change;

Change min_change(int value);

int main()
{
Change carry;
Change purchase;
Change exchange;
Change best_change;
int transactions = 10000000;
double best_result = 5;
double average;

int penny = 4;

for (; penny >= 0; penny--)
{
int nickel = 1;

for (; nickel >= 0; nickel--)
{
int dime = 2;

for (; dime >= 0; dime--)
{
int quarter = 3;

for (; quarter >= 0; quarter --)
{
int total_coins = 0;
int x = 0;

carry.penny = penny;
carry.nickel = nickel;
carry.dime = dime;
carry.quarter = quarter;

init_gen_rand(time(NULL));

for (; x<transactions; x++)
{

purchase = min_change(gen_rand32()%100);

exchange.penny = abs(purchase.penny - carry.penny);
exchange.nickel = abs(purchase.nickel - carry.nickel);
exchange.dime = abs(purchase.dime - carry.dime);
exchange.quarter = abs(purchase.quarter - carry.quarter);

total_coins += exchange.penny + exchange.nickel + exchange.dime + exchange.quarter;
}

average = (double)total_coins/transactions;

printf("Pennies: %d Nickels: %d Dimes: %d Quarters: %d\n", penny, nickel, dime, quarter);
printf("Average coins per transaction: %f\n\n", average);

if (average < best_result)
{
best_result = average;
best_change = carry;
}
}
}
}
}

printf("Best Result: %f\n", best_result);
printf("Pennies: %d Nickels: %d Dimes: %d Quarters: %d\n", best_change.penny, best_change.nickel, best_change.dime, best_change.quarter);

return 0;
}

Change min_change(int value)
{
Change min_change;

min_change.penny = 0;
min_change.nickel = 0;
min_change.dime = 0;
min_change.quarter = 0;

while (value)
{
if (value >= 25)
{
value -= 25;
min_change.quarter++;
}
else
{
if (value >= 10)
{
value -= 10;
min_change.dime++;
}
else
{
if (value >=5)
{
value -= 5;
min_change.nickel++;
}
else
{
value -= 1;
min_change.penny++;
}
}
}
}

return min_change;
}

If you want to compile it you will also need the SIMD-oriented Fast Mersenne Twister library: http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/


So the results the program generated:
Best Result: 3.198689
Pennies: 2 Nickels: 0 Dimes: 1 Quarters: 1

It's averaged over 10,000,000 transactions per combination.
Should be enough for statistical evidence.

EDIT: Best Result is the average number of coins leftover.
EDIT2: I should probably clarify, this isn't quite the answer the problem is looking for, but it is the answer to "What change should I carry to minimize my change received". But now that I think about it, even this isn't quite an answer, simply because 37 cents isn't enough to cover 38 cents, which means you'd have to pull out a $1 for that 1 cent which then makes your dollar 99 cents. This answer is merely the best combination of coins that matches average transactions the most.

Ah, you're correct. It isn't exact change, but an exact subset of the change needed. In some cases it will be exact, in others too much or too little.

EDIT:
The question is: How do you carry 4.7 coins?
You can't. But you can carry 5 coins. And carrying 4 coins means more often than not you wont have enough.
Knowing this, simply choosing the most probably occurring coins will yield the best result.

Yes you are indeed correct Builderboy. However, 4.7 coins is not an integer amount. So carrying 5 coins is still the optimal solution.

Here's my thoughts:
You know you will get 4.7 coins back on average, which is 5 coins when viewed as an integer amount.
To minimize your change, you need to predict what 5 coins those will be on average.