CareerCup

(zoomba)m = { 1 : [ 'a' , 'x' ] , 2 : ['b','y'] }
{1=@[ a,x ], 2=@[ b,y ]} // ZMap
(zoomba)join( @ARGS = list( '12'.value ) -> { m[int($.o)]} ) ->{str($.o,'') }
[ ab,ay,xb,xy ] // ZList

Hmm. Not that hard. Probably a standard recursive solution would help here, to make it harder and *interview* class:

/* standard recursion */
map = { 1 : [ 'a' , 'x' ] , 2 : ['b','y'] }

def _recurse(string, options, tmp='') {
   if ( empty(string) ){  options+= tmp ; return }
   head = string[0]
   tail = string[1:-1]
   for ( o :  map[ int(head) ] ){
     _recurse( tail, options, tmp + o )
   }
}

def mapper( string ){
  options = list()
  _recurse(string,options)
  options // return 
}
println( mapper('12') )

Solution in python. The cost is the result of multiplying each character of the string by the values that can be replaced for.

def computeCombinations(string, mapping):
    values = [ mapping[x] for x in string ]
    results = [[]]
    for v in values:
        results = [x + [y] for x in results
                           for y in v]
    return results

#include <string>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <map>
#include <list>
#include <stack>
#include <vector>

using namespace std;

map<char, list<char>> str = {
	{ '1', { 'a', 'b', 'c', 'd', 'e' } },
	{ '2', { 'v', 'w', 'x', 'y', 'z' } }
};
list<string> combs;

void getCombinations(string& currentCombination, string& sub) {
	if (sub.empty()) {
		combs.push_back(currentCombination);
		return;
	}
	for (auto ch : str[sub[0]]) {
		currentCombination.push_back(ch);
		getCombinations(currentCombination, sub.substr(1));
		currentCombination.pop_back();
	}
}

int main()
{
	string input = "12212";
	string currentCombination;
	getCombinations(currentCombination, input);
	
	for (auto combination : combs) {
		cout << combination << endl;
	}
	string line;
	cout << "Press enter to close" << endl;
	getline(cin, line);
	return 0;
}