X-Git-Url: https://git.cworth.org/git?p=mnemon;a=blobdiff_plain;f=mnemon.c;h=9f28dfeb7a88dce584484c5648fafa0b75e49f6e;hp=039f0ca0115325a6163018d47f1f1b68e53529a2;hb=8b5aa52c7a54686d9b4b9d8d117d490eb3b66ba6;hpb=c456eaba63d93aa02a184e4ead0c85fed3827bee diff --git a/mnemon.c b/mnemon.c index 039f0ca..9f28dfe 100644 --- a/mnemon.c +++ b/mnemon.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -28,14 +29,19 @@ #include #include +#include +#include + +typedef int bool_t; + typedef struct _item { - int count; + int score; char *challenge; char *response; } item_t; typedef struct _bin { - int count; + int score; int items_size; int num_items; item_t **items; @@ -120,11 +126,11 @@ xasprintf (char **strp, const char *fmt, ...) static void item_init (item_t *item, - int count, + int score, const char *challenge, const char *response) { - item->count = count; + item->score = score; item->challenge = xmalloc (strlen (challenge) + 1 + strlen (response) + 1); @@ -180,7 +186,7 @@ category_grow (category_t *category) static item_t * category_add_item (category_t *category, - int count, + int score, const char *challenge, const char *response) { @@ -191,7 +197,7 @@ category_add_item (category_t *category, item = &category->items[category->num_items++]; - item_init (item, count, challenge, response); + item_init (item, score, challenge, response); return item; } @@ -208,7 +214,7 @@ category_print (category_t *category, if (i != 0) fprintf (file, "\n"); fprintf (file, "%d\n%s\n%s\n", - item->count, + item->score, item->challenge, item->response); } @@ -216,9 +222,9 @@ category_print (category_t *category, static void bin_init (bin_t *bin, - int count) + int score) { - bin->count = count; + bin->score = score; bin->items_size = 0; bin->num_items = 0; @@ -247,7 +253,7 @@ static void bin_add_item (bin_t *bin, item_t *item) { - assert (item->count == bin->count); + assert (item->score == bin->score); if (bin->num_items == bin->items_size) bin_grow (bin); @@ -255,6 +261,18 @@ bin_add_item (bin_t *bin, bin->items[bin->num_items++] = item; } +static void +bin_remove_item (bin_t *bin, + int item_index) +{ + /* Replace the current item with the last item, (no need to shift + * any more than that since we don't care about the order of the + * items within a bin). */ + bin->num_items--; + if (bin->num_items) + bin->items[item_index] = bin->items[bin->num_items]; +} + static void mnemon_init (mnemon_t *mnemon) { @@ -337,30 +355,44 @@ mnemon_bins_grow (mnemon_t *mnemon) static bin_t * mnemon_get_bin (mnemon_t *mnemon, - int count) + int score) { int i; bin_t *bin; for (i = 0; i < mnemon->num_bins; i++) - if (mnemon->bins[i].count == count) + if (mnemon->bins[i].score == score) return &mnemon->bins[i]; - else if (mnemon->bins[i].count > count) + else if (mnemon->bins[i].score > score) break; - mnemon_bins_grow (mnemon); + if (mnemon->num_bins == mnemon->bins_size) + mnemon_bins_grow (mnemon); bin = &mnemon->bins[i]; /* Make room to insert new bin at its sorted location. */ - memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t)); + if (i < mnemon->num_bins) + memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t)); mnemon->num_bins++; - bin_init (bin, count); + bin_init (bin, score); return bin; } +static void +mnemon_remove_bin (mnemon_t *mnemon, + bin_t *bin) +{ + int i = bin - mnemon->bins; + + bin_fini (bin); + + memmove (bin, bin + 1, (mnemon->num_bins - i) * sizeof (bin_t)); + mnemon->num_bins--; +} + static void chomp (char *s) { @@ -397,7 +429,7 @@ mnemon_load_category (mnemon_t *mnemon, category = mnemon_get_category (mnemon, name); while (1) { - int count; + int score; char *challenge, *response; /* Read bin number (ignoring blank separator lines) */ @@ -409,7 +441,7 @@ mnemon_load_category (mnemon_t *mnemon, chomp (line); } while (*line == '\0'); - count = strtol (line, &end, 10); + score = strtol (line, &end, 10); if (*end != '\0') { fprintf (stderr, "Failed to parse bin number from \"%s\" at %s:%d\n", line, path, line_count); @@ -432,7 +464,7 @@ mnemon_load_category (mnemon_t *mnemon, chomp (line); response = line; - category_add_item (category, count, challenge, response); + category_add_item (category, score, challenge, response); free (challenge); } @@ -451,7 +483,7 @@ mnemon_load_category (mnemon_t *mnemon, * bin. */ for (i = 0; i < category->num_items; i++) { item_t *item = &category->items[i]; - bin_t *bin = mnemon_get_bin (mnemon, item->count); + bin_t *bin = mnemon_get_bin (mnemon, item->score); bin_add_item (bin, item); } @@ -515,7 +547,7 @@ mnemon_save (mnemon_t *mnemon) err = rename (lock_filename, filename); if (err < 0) { - fprintf (stderr, "Error: Failes to rename %s to %s: %s\n", + fprintf (stderr, "Error: Failed to rename %s to %s: %s\n", lock_filename, filename, strerror (errno)); continue; } @@ -525,15 +557,198 @@ mnemon_save (mnemon_t *mnemon) } } +/* Return a uniformly-distributed pseudo-random integer within the + * range: + * + * 0 <= result < num_values + */ +static int +rand_within (int num_values) +{ + return (int) (num_values * (rand() / (RAND_MAX + 1.0))); +} + +/* Return an exponentially-distributed pseudo-random integer within + * the range: + * + * 0 <= result < num_values + * + * The distribution is such that each successively larger value will + * occur with a probability of half of the previous value. + */ +static int +rand_within_exponential (int num_values) +{ + static int r; + static uint32_t mask = 0; + int ones; + int bit; + + /* Optimize the constant case. */ + if (num_values == 1) + return 0; + + ones = 0; + + do { + if (mask == 0) { + r = rand (); + mask = 1 << 31; + while (mask > RAND_MAX) + mask >>= 1; + } + bit = r & mask; + mask >>= 1; + if (bit) { + ones++; + if (ones == num_values) + ones = 0; + } + } while (bit); + + return ones; +} + +static void +mnemon_select_item (mnemon_t *mnemon, + bin_t **bin_ret, + int *item_index_ret) +{ + int bin_index; + bin_t *bin; + + bin_index = rand_within_exponential (mnemon->num_bins); + + bin = &mnemon->bins[bin_index]; + + *bin_ret = bin; + *item_index_ret = rand_within (bin->num_items); +} + +static void +mnemon_do_challenges (mnemon_t *mnemon, + int to_introduce) +{ + bin_t *bin; + int item_index; + item_t *item; + char *response; + bool_t correct; + int unlearned; + int i; + + /* Count the number of items with negative scores. */ + unlearned = 0; + for (i = 0; i < mnemon->num_bins; i++) { + bin = &mnemon->bins[i]; + if (bin->score >= 0) + break; + unlearned += bin->num_items; + } + + to_introduce -= unlearned; + if (to_introduce < 0) + to_introduce = 0; + + if (unlearned) { + printf ("You've got %d items to learn already. ", unlearned); + if (to_introduce) + printf ("I'll introduce %d more as we go.", to_introduce); + printf ("\n"); + } else { + printf ("Introducing %d new items.\n", to_introduce); + } + printf ("\n"); + + do { + mnemon_select_item (mnemon, &bin, &item_index); + + if (bin->score == 0) + to_introduce--; + + item = bin->items[item_index]; + + printf ("%s\n", item->challenge); + + response = readline ("> "); + if (response == NULL) { + printf ("\n"); + break; + } + + correct = (strcmp (response, item->response) == 0); + + bin_remove_item (bin, item_index); + + /* If the bin is now empty, we must remove it. Also if we just + * picked the last word we'll ever pick from the bin with + * score 0, then we can remove that as well. */ + if (bin->num_items == 0 || + (bin->score == 0 && to_introduce == 0)) + { + mnemon_remove_bin (mnemon, bin); + } + + if (correct) { + item->score++; + /* We reserve an item score of 0 for an item that has + * never been asked. */ + if (item->score == 0) { + item->score = 1; + unlearned--; + printf ("You got it!"); + } else if (item->score < 0) { + printf ("Yes---just give me %d more.", + - item->score); + } else if (item->score == 1) { + printf ("On your first try, no less!"); + } else { + printf ("Masterful (%dx).", item->score); + } + } else { + printf (" %s is the correct answer.", + item->response); + if (item->score >= 0) + unlearned++; + item->score--; + /* Penalize an incorrect response by forcing the score + * negative. */ + if (item->score >= 0) { + item->score = -1; + printf ( " Oops, you knew that, right?\n "); + } + } + + printf (" ("); + if (to_introduce) + printf ("%d to come.", to_introduce); + if (to_introduce && unlearned) + printf (" "); + if (unlearned) + printf ("%d still unlearned.", unlearned); + if (to_introduce == 0 && unlearned == 0) + printf ("Great job!"); + printf (")\n\n"); + + bin = mnemon_get_bin (mnemon, item->score); + + bin_add_item (bin, item); + } while (unlearned || to_introduce); +} + int main (int argc, char *argv[]) { mnemon_t mnemon; + srand (time (NULL)); + mnemon_init (&mnemon); mnemon_load (&mnemon); + mnemon_do_challenges (&mnemon, 10); + mnemon_save (&mnemon); mnemon_fini (&mnemon);