Введите первый множитель: 123*
Введите второй множитель: 2*
Введите произведение: 246**
Найденные числа:
1230 * 20 = 24600
1231 * 20 = 24620
1232 * 20 = 24640
1233 * 20 = 24660
1234 * 20 = 24680

#include <iostream>
#include <locale>
#include <limits>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>

using namespace std;

// Класс число
class number
{
public:
	number(){};
	// Следующая подстановка
	bool next();
	// Операторы
	bool operator==(const number& right) const;
	number operator*(const number& right) const;
private:
	typedef unsigned char _itemType;
	typedef vector<_itemType> _byteVector;
	explicit number(_byteVector digits);
	// Цифры числа
	_byteVector _digits;
	// Позиции звездочек
	_byteVector _stars;
	template<class _Elem,class _Traits> friend basic_istream<_Elem,_Traits>& operator>>(basic_istream<_Elem,_Traits>& stream,number& right);
	template<class _Elem,class _Traits> friend basic_ostream<_Elem,_Traits>& operator<<(basic_ostream<_Elem,_Traits>& stream,const number& right);
};

// Оператор ввода
template<class _Elem,class _Traits>
basic_istream<_Elem,_Traits>& operator>>(basic_istream<_Elem,_Traits>& stream,number& right)
{
	typedef basic_string<_Elem,_Traits> _strType;
	_strType str;
	stream>>str;
	if(!stream.fail())
	{
		const ctype<_Elem>& facet=use_facet<ctype<_Elem> >(stream.getloc());
		const _Elem zero=facet.widen('0');
		_strType::size_type notZero=str.find_first_not_of(zero);
		if(notZero==_strType::npos)
		{
			notZero=str.length()-1;
		}
		str.erase(0,notZero);
		_strType::size_type index=str.length();
		number::_byteVector digits,stars;
		bool success=true;
		while(index-- && success)
		{
			_Elem ch=str[index];
			if(facet.is(facet.digit,ch))
			{
				digits.push_back(ch-zero);
			}
			else if(ch==facet.widen('*'))
			{
				digits.push_back(index==0);
				stars.push_back(digits.size()-1);
			}
			else
			{
				success=false;
			}
		}
		if(success)
		{
			right._digits=digits;
			right._stars=stars;
		}
		else
		{
			stream.setstate(stream.badbit);
		}
	}
	return stream;
}

// Оператор вывода
template<class _Elem,class _Traits>
basic_ostream<_Elem,_Traits>& operator<<(basic_ostream<_Elem,_Traits>& stream,const number& right)
{
	basic_stringstream<_Elem,_Traits> sstr;
	for(number::_byteVector::const_reverse_iterator it=right._digits.rbegin(),end=right._digits.rend();it!=end;++it)
	{
		sstr<<static_cast<unsigned int>(*it);
	}
	return stream<<sstr.str();
}

number input(const char* const msg);

int main()
{
	setlocale(LC_ALL,"russian");
	// Вводим данные
	number num1=input("Первый множитель:"),
		num2=input("Второй множитель:"),
		num3=input("Произведение:");
	// Счетчик найденных решений
	size_t count=0;
	do
	{
		do
		{
			// Умножаем
			number mult=num1*num2;
			// Сравниваем
			if(mult==num3)
			{
				// Решение найдено - выводим
				cout<<num1<<'*'<<num2<<'='<<mult<<endl;
				++count;
			}
		}while(num2.next()); // Следующий вариант
	}while(num1.next());    // Следующий вариант
	if(count)
	{
		cout<<"Найдено "<<count<<" вариантов ответов"<<endl;
	}
	else
	{
		cout<<"Решение не найдено"<<endl;
	}
	system("PAUSE");
	return 0;
}

// Ввод числа
number input(const char* const msg)
{
	while(true)
	{
		cout<<msg;
		number result;
		cin>>result;
		if(cin.fail())
		{
			cout<<"Ошибочный ввод"<<endl;
			cin.clear();
			cin.ignore(numeric_limits<streamsize>::max(),'\n');
		}
		else
		{
			cin.ignore(numeric_limits<streamsize>::max(),'\n');
			return result;
		}
	}
}

// Генерирует следующий вариант.
// Возвращает false когда все варианты перебраны
bool number::next()
{
	for(_byteVector::const_iterator it=_stars.begin(),end=_stars.end();it!=end;++it)
	{
		_itemType digit=_digits[*it]+1;
		if(digit>9)
		{
			_digits[*it]=*it==(_digits.size()-1);
		}
		else
		{
			_digits[*it]=digit;
			return true;
		}
	}
	return false;
}

// Оператор равенства
bool number::operator==(const number& right) const
{
	_byteVector::size_type size=_digits.size(),index=0;
	if(size!=right._digits.size())
	{
		return false;
	}
	bool result=true;
	while(index<size && result)
	{
		// Не учитываем места расположения звездочек
		if(find(_stars.begin(),_stars.end(),index)==_stars.end() &&
			find(right._stars.begin(),right._stars.end(),index)==right._stars.end())
		{
			result=_digits[index]==right._digits[index];
		}
		++index;
	}
	return result;
}

number::number(number::_byteVector digits)
	:_digits(digits)
{
}

// Оператор умножения
// Использует длинную арифметику
number number::operator*(const number& right) const
{
	_byteVector resultData(_digits.size()+right._digits.size(),0);
	for(_byteVector::size_type i=0,end=right._digits.size();i<end;++i)
	{
		_itemType digit=right._digits[i];
		_byteVector tmpVector(_digits.size());
		unsigned int carry=0;
		for(_byteVector::size_type j=0,end=_digits.size();j<end;++j)
		{
			unsigned int tmp=_digits[j]*digit+carry;
			carry=tmp/10;
			tmpVector[j]=tmp%10;
		}
		if(carry)
		{
			tmpVector.push_back(carry);
			carry=0;
		}
		for(_byteVector::size_type j=0,end=tmpVector.size();j<end;++j)
		{
			unsigned int tmp=resultData[i+j]+tmpVector[j]+carry;
			carry=tmp/10;
			resultData[i+j]=tmp%10;
		}
		if(carry)
		{
			_byteVector::size_type index=tmpVector.size()+i;
			if(index<resultData.size())
			{
				resultData[index]=carry;
			}
			else
			{
				resultData.push_back(carry);
			}
		}
	}
	// Удалим ведущие нули. Если есть.
	while(!resultData.back() && resultData.size()>1)
	{
		resultData.pop_back();
	}
	return number(resultData);
}

Первый множитель:4*58
Второй множитель:564*
Произведение:*6275*78
4658*5641=26275778
Найдено 1 вариантов ответов