Penalize an incorrect item down to a score of -2

[mnemon] / mnemon.c

diff --git a/mnemon.c b/mnemon.c
index 737298ed045f4877765118845e2626050ec816bc..920f548f83466729a5c27f4cd2523b99d207774b 100644 (file)
--- a/mnemon.c
+++ b/mnemon.c
@@ -35,13 +35,13 @@
 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;
@@ -126,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);
@@ -186,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)
 {
@@ -197,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;
 }
@@ -214,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);
     }
@@ -222,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;
@@ -253,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);
@@ -355,26 +355,28 @@ 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;
 }
@@ -427,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) */
@@ -439,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);
@@ -462,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);
     }
@@ -481,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);
     }
@@ -635,11 +637,11 @@ mnemon_do_challenges (mnemon_t *mnemon,
     int unlearned;
     int i;
 
-    /* Count the number of items with negative counts. */
+    /* Count the number of items with negative scores. */
     unlearned = 0;
     for (i = 0; i < mnemon->num_bins; i++) {
        bin = &mnemon->bins[i];
-       if (bin->count >= 0)
+       if (bin->score >= 0)
            break;
        unlearned += bin->num_items;
     }
@@ -661,7 +663,7 @@ mnemon_do_challenges (mnemon_t *mnemon,
     do {
        mnemon_select_item (mnemon, &bin, &item_index);
 
-       if (bin->count == 0)
+       if (bin->score == 0)
            to_introduce--;
 
        item = bin->items[item_index];
@@ -680,40 +682,45 @@ mnemon_do_challenges (mnemon_t *mnemon,
 
        /* 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
-        * count 0, then we can remove that as well. */
+        * score 0, then we can remove that as well. */
        if (bin->num_items == 0 ||
-           (bin->count == 0 && to_introduce == 0))
+           (bin->score == 0 && to_introduce == 0))
        {
            mnemon_remove_bin (mnemon, bin);
        }
 
        if (correct) {
-           item->count++;
-           /* We reserve an item count of 0 for an item that has
+           item->score++;
+           /* We reserve an item score of 0 for an item that has
             * never been asked. */
-           if (item->count == 0) {
-               item->count = 1;
+           if (item->score == 0) {
+               item->score = 1;
                unlearned--;
                printf ("You got it!");
-           } else if (item->count < 0) {
+           } else if (item->score < 0) {
                printf ("Yes---just give me %d more.",
-                       - item->count);
-           } else if (item->count == 1) {
+                       - item->score);
+           } else if (item->score == 1) {
                printf ("On your first try, no less!");
            } else {
-               printf ("Masterful.");
+               printf ("Masterful (%dx).", item->score);
            }
        } else {
            printf ("  %s is the correct answer.",
                    item->response);
-           if (item->count >= 0)
-               unlearned++;
-           item->count--;
-           /* Penalize an incorrect response by forcing the count
+           /* Penalize an incorrect response by forcing the score
             * negative. */
-           if (item->count >= 0) {
-               item->count = -1;
-               printf ( " Oops, you knew that, right?\n ");
+           if (item->score >= 0) {
+               if (item->score > 0)
+                   printf ( " Oops, you knew that, right?\n ");
+               unlearned++;
+               /* We go to -2 to force a little extra reinforcement
+                * when re-learning an item, (otherwise, it will often
+                * get asked again immediately where it is easy to get
+                * a correct response without any learning). */
+               item->score = -2;
+           } else {
+               item->score--;
            }
        }
 
@@ -728,7 +735,7 @@ mnemon_do_challenges (mnemon_t *mnemon,
            printf ("Great job!");
        printf (")\n\n");
 
-       bin = mnemon_get_bin (mnemon, item->count);
+       bin = mnemon_get_bin (mnemon, item->score);
 
        bin_add_item (bin, item);
     } while (unlearned || to_introduce);