Ich versuche gerade ein Programm zu schreiben, welches mir in einer Art "brutforce" Verfahren alle verschiedenen Kombinationsmöglichkeiten auf listet in Abhängigkeit zu einer maximalen Stellenanzahl n, welche am Anfang gegeben wird.

Also angenomme ich habe n=3 und an jeder Stelle n können 3 verschiedene Werte stehen (-1 , 0 , 1). Ich habe zuerst versucht das ganze in Basic zu realisieren, nur erwies sich die Geschwindigkeit, mit der "Keys" erstellt werden, als nicht aktzeptabel

Es wäre sehr nett wenn mir jemand ein paar Tips geben, oder wenn er viel Zeit, Lust und Lageweile hat vielleicht auch einen Lösungsansatz geben könnte.

mfg escio

Die Sache ist nur die, bei geschachtelten for-Schleifen muss ich doch per Hand für jedes "n" ne neue Schachtelung vornehmen, also im Quelltext.

Habe leider keine Ahung, wie ich ihm sagen kann, wieviele for-Schleifen er laufen lassen muss, denn umso höher n wird, desto höher wird doch auch die Anzahl der gebrauchten Schleifen?!

da gibts ja in der stl ein paar gute funktionen...

Felix

namespace BruteForce
{
    template <class CryptClass> /*std::string CryptClass::EnCode (std::string)*/
    class TDepth
        {
        private:
            std::string m_Hash;
            std::string m_Ergebnis;
            std::vector <char> Characters;
            std::vector <char>::const_iterator Characters_first;
            std::vector <char>::const_iterator Characters_end;
            size_t m_Depth;
            std::ofstream& output;
            bool doing (const std::string &curr = "", size_t length = 0)
				{
					if (CryptClass::EnCode (curr) == m_Hash)
					{
						m_Ergebnis = curr;
						return true;
					}
					else if (length != m_Depth)
					{
						++length;
						for (std::vector <char>::const_iterator iter (Characters_first); iter != Characters_end; ++iter)
						{
							if (doing (curr + *iter, length))
							return true;
						}
					}
					return false;
				}
			public:
				TDepth (const std::string &hash = "", std::ofstream &_output = std::cout)
					: m_Hash (hash), Characters (0), output (_output)
					{}
				void SetHash (const std::string &hash)					{m_Hash = hash;};
				std::string GetHash (void) const						{return m_Hash;};
				void SetDepth (const size_t &depth)						{m_Depth = depth;};
				std::string GetErgebnis (void) const					{return m_Ergebnis;};
				void SetVector (const std::vector <char> &newvector)	{Characters = newvector;};
				void AddCharacter (const char toadd)					{Characters.push_back (toadd);};
				bool CheckCharacter (const char toproof) const
				{
					for (std::vector <char>::const_iterator iter (Characters.begin ()); iter != Characters.end (); ++iter)
					{
						if (*iter == toproof)
							return true;
					}
					return false;
				}
				void AddCharacters (const std::string &ToAdd)
				{
					for (std::string::const_iterator iter (ToAdd.begin ()); iter != ToAdd.end (); ++iter)
					{
						if (CheckCharacter (*iter))
							continue;
						Characters.push_back (*iter);
					}
				}
				void Do (void) throw (::my::exception::FAILED_OP)
				{
					if (CanPrint)
					{
						if (m_Hash.empty ())
							output << "warning: there isnt set a hash!" << std::endl;
						if (Characters.empty ())
							output << "warning: there isnt set any character!" << std::endl;
						if (!m_Depth)
							output << "warning: depth is zero!" << std::endl;
					}
					Characters_end = Characters.end ();
					Characters_first = Characters.begin ();
					if (!doing ())
						throw ::my::FAILED_OP ("Advance parameters for solving this");
				}
}

my is nen namespace und failed_op is ne exception - kannst dafür auch std::runtime_exception nehmen oder so was in der richtung...

bb