Question

I am creating a Font Mapping program where I want to map 2 fonts of different languages.

For eg A in Arial Font(English) will map with अ in Kruti Dev Font(Hindi).

I have a created this conversion in a database this way:

Native_Font     |     Foreign_Language_Font
-------------------------------------------
       A        |              अ
       B        |              बी

If conversion was restricted only for characters it was OK. Read each character of native font and find its matching character in Foreign Language Font. (I have done it)

But now I have to do it for strings also and that’s where the real problem starts.

If a string is provided in database, then convert it fully. But if its conversion does not exist find conversion for one character less.

An example would be

In Database

Native_Font     |     Foreign_Language_Font
-------------------------------------------
    Cha         |              चा
     r          |              र
     t          |              ट

and word Chart is given to translate.

1. It would first try to convert Full word Chart. If its mapping is found give at once.
2. But if it does not find direct conversion for Chart then Go for Char. If its mapping is found give at once, then find respective character of t

and so on

Chart

Char t

Cha rt
Cha r t

Ch art
Ch ar t
Ch a r t

C hart
C har t
C ha r t
C h a r t

Moreover if a mapping is not found, it should be replaced by native font character. How to do it? I am sure recursion should be used. But How?

Answer 1

I’d approach it with a greedy algorithm. Something like this:

    // warning, untested
    public String Translate(String s, Dictionary<String, String> mapping)
    {
        String result = "";
        if (RecurTranslate(s, mapping, ref result))
            return result;

        throw new Exception("No translation");
    }

    private bool RecurTranslate(String s, Dictionary<String, String> mapping, ref String result)
    {
        if (s.Length == 0)
            return true;

        for (int prefixLen = s.Length; prefixLen > 0; --prefixLen)
        {
            String prefix = s.Substring(0, prefixLen);
            String trans;
            if (mapping.TryGetValue(prefix, out trans))
            {
                if (RecurTranslate(s.Substring(prefixLen), mapping, ref result))
                {
                    result = trans + result;
                    return true;
                }
            }
            else if (prefixLen == 1)
            {   // this branch allows a character to stand for itself
                if (RecurTranslate(s.Substring(prefixLen), mapping, ref result))
                {
                    result = prefix + result;
                    return true;
                }
            }
        }

        return false;
    }

This starts from the front, looking for the largest possible match. Depending on your data, other approaches might be better – say, going through the mapping in length order to find the longest match and splitting from there:

    private bool RecurTranslate2(String s, Dictionary<String, String> mapping, ref String result)
    {
        if (s.Length == 0)
            return true;

        foreach (var entry in mapping.Where(e => e.Key.Length <= s.Length).OrderByDescending(e => e.Key.Length))
        {
            if (s.Contains(entry.Key))
            {   // split into a before and after
                int idx = s.IndexOf(entry.Key);
                String before = s.Substring(0, idx);
                String after = s.Substring(idx + entry.Key.Length);
                String bRes = "", aRes = "";
                if (RecurTranslate2(before, mapping, ref bRes) && RecurTranslate2(after, mapping, ref aRes))
                {
                    result = aRes + entry.Value + bRes;
                    return true;
                }
            }
        }

        return false;
    }

Finally, you might play with combining these methods: use RecurTranslate2 until you get to some length threshold and then switch to RecurTranslate.

Responding to comment: See new else branch for failed lookup