Forgotten (failing!) Soundex Test

[ajneu]

Hi,

this test was forgotten and fails:

TEST_F(SoundexEncoding, ForgetMeNot)
{
  ASSERT_THAT(soundex.encode("bahb"), Eq("B100"));
}

https://www.wolframalpha.com/input/?i=Soundex+bahb

It's not enough to just check the last character (ref).

Then there are also special corner cases, which according to Wolfram Soundex are:

TEST_F(SoundexEncoding, Corner)
{
  ASSERT_THAT(soundex.encode("Aaabwhwb"), Eq("A110"));
  ASSERT_THAT(soundex.encode("Aaabhwhb"), Eq("A110"));
}

https://www.wolframalpha.com/input/?i=Soundex+Aaabwhwb
https://www.wolframalpha.com/input/?i=Soundex+Aaabhwhb

[ajneu]

Edit: code changed a bit for more "nicefullnesssss"....

#ifndef SOUNDEX_H
#define SOUNDEX_H

#define NON_DIG_TO_ZERO

class Soundex {
 private:
  struct CodeIter {
    std::string::const_iterator it;
    char code;
  };

 public:
  std::string encode(const std::string &word) {
    CodeIter   curr   = {word.cbegin()};
    const auto end_it =  word.cend();

    char output_str[totCodeLen+1] = {};
    if (curr.it != end_it) {
      curr.code = encoder(*curr.it);
      char       *out_it  = output_str;
      const char *out_end = out_it + totCodeLen;

      Skipped skipped      = nothing;
      Skipped skipped_prev;

      *out_it = toupper(*curr.it);
      ++out_it;

      char prev_code = curr.code;

      while (++curr.it != end_it) {
        skipped_prev = skipped;
        if ((skipped = getSkipped(*curr.it, skipped_prev)) != nothing) {
          continue;
        }

        curr.code = encoder(*curr.it);
        if (curr.code == prev_code) {
          if (skipped_prev != aeiouy_non_hw) {
            continue;
            /* already coded:
               either because of being adjacent to predecessor (of equal code), 
               or because of being separated by w_only or h_only from predecessor (of equal code))
            */
          }
        }

        *out_it = curr.code;     // write code to output
        if (++out_it == out_end)
          break;

        prev_code = curr.code;
      }
      for (; out_it != out_end; ++out_it) {
        *out_it = '0';
      }

    }
    return output_str;
  }

 private:
  enum Skipped {nothing, aeiouy_non_hw, h_only, w_only};
  static constexpr std::string::size_type totCodeLen = 4;

  Skipped getSkipped(const char c, Skipped skipped_prev)
  {
    Skipped skipped;
    switch (tolower(c)) {
    case 'a': case 'e': case 'i': case 'o': case 'u': case 'y':
      skipped = aeiouy_non_hw;
      break;
    case 'w':
      skipped = w_only;
      break;
    case 'h':
      skipped = h_only;
      break;
    default:
      return nothing;     /*!*/
      break;
    }

    return (((skipped_prev == nothing) || (skipped_prev == skipped))
            ? skipped
            : aeiouy_non_hw);
  }

  static const char encoder(char c)
  {
    char code;

    c = tolower(c);
    switch(c) {
    case 'b': case 'f': case 'p': case 'v':
      code = '1';
      break;
    case 'c': case 'g': case 'j': case 'k': case 'q': case 's': case 'x': case 'z':
      code = '2';
      break;
    case 'd': case 't':
      code = '3';
      break;
    case 'l':
      code = '4';
      break;
    case 'm': case 'n':
      code = '5';
      break;
    case 'r':
      code = '6';
      break;
    default:
#ifdef NON_DIG_TO_ZERO
      code = '0';
#else
      code = c;
#endif
      break;
    }
    return code;
  }

};

#endif

What can I say... I guess once in a while... "for kicks", I tend to like optimized "low-fat" versions, that don't pull in maps and extra std-strings; and flirt a bit with mild obfuscation. ;)

More seriously:
Note that the skipped-characters-handling has a kind of "memory" here (by passing skipped_prev to getSkipped).

[jlangr]

thanks for the missing tests and exploration of an optimized version!