Calculate variations on a string

Question

I have a series of incorrectly encoded base36 values - these were encoded from integers using a string of letters missing the "i" and "o". They now need to be converted back to integers (using c#)

There are multiple permutations because of the rollover effect.

"0" can either equal 0 or 34 "1" can either equal 1 or 35.

So, for instance if I have a string "a110", this has six possible values.

I'm having a hard time trying to figure how to code for this. All the examples I've looked at have variations of a set of elements: for example.

char[] = { a, b, c }

int[] = { 1, 2, 3 }

however in my case there are conditionals involved too, and it's making my head hurt. can anyone help?

Answer 1

I managed to do it with the following code. It was actually a little simpler than I expected, since I only had two conditions, and two options. It uses recursion and steps through each character in the string. If that character is a 0 or 1, it then diverges, and continues building the string.

It actually generates a few duplicates, so I had to add a condition to only add it to the string list if it doesn't already exist. If someone else can point me to slightly better logic I'd appreciate it

public string st = "101"; // hardcoded for now
public char[] cs;
public List<string> variations;

static void Main()
{
    cs = st.ToCharArray();
    variations = new List<string>();
    vary("",0);
}

static void vary(string m, int n)
{     
    for (int i = n; i < cs.Count(); i++)
    {
        if (cs[i] == '0' || cs[i] == '1')
        {
            // recurse
            combo(m + (cs[i] == '0' ? "0" : "1"), i + 1);
            combo(m + (cs[i] == '0' ? "Y" : "Z"), i + 1);
        }
        m += cs[i];
    }
    if(!variations.Contains(m))
        variations.Add(m);
}

for the string "101" I get the following combinations

101
10Z
1Y1
1YZ
Z01
Z0Z
ZY1
ZYZ

Answer 2

You can compute the list of all possible input strings. First, read the input into a list of ints. Now, you know that each of those (if it's a sufficiently low value) could be one of two things. So then you can create an enumerator that returns all of the possible inputs, via a recursive descent.