Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » Rätselecke » 3*17. Virtual Rästel: Zielgerichteter Wurm

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] [ 2 ] > 3 <
020
26.09.2003, 13:46 Uhr
virtual
Sexiest Bit alive
(Operator)


Zumal Du etwas sortierst, was bereits sortiert ist, denke ich mir grade

C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::sort(wort.begin(), wort.end());

     for(std:string::size_type i=0; i<muster.length(); ++i)
     {
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


4 Posts und wir sind fertig, nach meiner Vorstellung jedenfalls
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)

Dieser Post wurde am 26.09.2003 um 13:47 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
021
26.09.2003, 13:52 Uhr
0xdeadbeef
Gott
(Operator)


Ach autsch. Da hab ich die Parameterreihenfolge durcheinandergebracht...

C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;
     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
022
26.09.2003, 13:58 Uhr
virtual
Sexiest Bit alive
(Operator)


Hm, du machst mich ratend...

C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>
#include <cctype>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;
     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
          std::string::size_type j;
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
023
26.09.2003, 14:03 Uhr
0xdeadbeef
Gott
(Operator)


Du mich auch.

C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>
#include <cctype>
#include <algorithm>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;

     std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);

     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
          std::string::size_type j;
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
024
26.09.2003, 14:12 Uhr
virtual
Sexiest Bit alive
(Operator)


Na dann.Das Transform müsste aber auch noch fürs wordlist gemacht werden.
Aber ich wills mal partiell reusen, was Du gemacht hast:


C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>
#include <cctype>
#include <algorithm>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;

     std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);

     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
          std::string::size_type j;
          if (std::string::npos==(j=wort.find(s[i])) && std::string::npos==(j=wort.find(toupper(s[i]))))
          {
          }
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
025
26.09.2003, 14:20 Uhr
0xdeadbeef
Gott
(Operator)


Dessen bin ich mir bewußt.

C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>
#include <cctype>
#include <algorithm>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;

     std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);

     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
          std::string::size_type j;
          if (std::string::npos==(j=wort.find(s[ i ])) && std::string::npos==(j=wort.find(toupper(s[ i ]))))
          {
          }
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::transform(input.begin(), input.end(),  (int(*)(int)) tolower);
     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
026
26.09.2003, 14:25 Uhr
virtual
Sexiest Bit alive
(Operator)



C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>
#include <cctype>
#include <algorithm>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;

     std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);

     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
          std::string::size_type j;
          if (std::string::npos==(j=wort.find(s[ i ])) && std::string::npos==(j=wort.find(toupper(s[ i ]))))
          {
          }
          wort.erase(j, 1);
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::transform(input.begin(), input.end(),  (int(*)(int)) tolower);
     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


Hm. fast Fertig. Nur ein statement noch...
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
027
26.09.2003, 14:28 Uhr
virtual
Sexiest Bit alive
(Operator)


Igitt, ist dieser Cast häßlich
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
028
26.09.2003, 14:38 Uhr
0xdeadbeef
Gott
(Operator)



C++:
#include <iostream>
#include <fstream>
#include <string>
#include <list>
#include <iterator>
#include <cctype>
#include <algorithm>

#define DICFILE "dictionary"

bool checkMatch(
     const std::string& muster,
     std::string wort)
{
     std::string s = muster;

     std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);

     std::sort(wort.begin(), wort.end());

     for(std::string::size_type i=0; i<muster.length(); ++i) //<--Tipfeeler korrigiert
     {
          std::string::size_type j;
          if (std::string::npos==(j=wort.find(s[ i ])) && std::string::npos==(j=wort.find(toupper(s[ i ]))))
          {
               return false;
          }
          wort.erase(j, 1);
     }    
     return true;
}

int main(int argc, char** argv)
{
     if(argc > 2) // Hilfe ausgeben
     {
     }

     std::cout << "Geben Sie das Musterwort ein: ";    
     std::string input;
     std::cin >> input;

     std::transform(input.begin(), input.end(),  (int(*)(int)) tolower);
     std::sort(input.begin(), input.end());

     std::ifstream dic(DICFILE);
     std::list<std::string> wordlist;
     std::copy(std::istream_iterator<std::string>(dic),  
                   std::istream_iterator<std::string>(),
                   std::back_inserter(wordlist));
    for(std::list<std::string>::iterator itr = wordlist.begin(); itr != wordlist.end(); ++itr)
    {
         if (checkMatch( *itr, input))
         {
              std::cout<<(*itr)<<std::endl;
         }
    }
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
029
26.09.2003, 14:39 Uhr
0xdeadbeef
Gott
(Operator)


Hm. Meine Idee war, die strings beide nach lowercase und sortiert zu bringen, und dann von vorne durchzulaufen. Aber so gehts auch.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] [ 2 ] > 3 <     [ Rätselecke ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: