Wrod Jbmlue

[Browni3141]

Aoccdrnig to a rscheearch at Cmabrigde Uinervtisy, it deosn’t mttaer in waht oredr the ltteers in a wrod are, the olny iprmoetnt tihng is taht the frist and lsat ltteer be at the rghit pclae. The rset can be a toatl mses and you can sitll raed it wouthit porbelm. Tihs is bcuseae the huamn mnid deos not raed ervey lteter by istlef, but the wrod as a wlohe.

Tihs is iertiesnntg if you h'venat seen it bfoere.

[Return 0]

Try writing source code this way and see how readable it is.

[ultifinitus]

You should definitely define all your keywords like that

#define srtnig  string
#define cahr    char
#define igetenr int
#define vtoecr  vector 

confuse the heck out of anyone perusing your code.

[Bazzy]

I hvae seen taht bfroee, but it olny wkors if you raed it fsat, whiutot cnairg too mcuh aoubt the wrods

[quirkyusername]

Woll Smoth approves

http://i25.tinypic.com/2iqeiis.jpg

[wolfgang]

typedef std::string sitnrg;
typedef char        cetaarhcr;
typedef int         igeetnr;
typedef double      dbolue;

[hamsterman]

You should definitely define all your keywords like that

Indeed. And you should define every possible variant so that flaot, falot, faolt, foalt, folat and float can all be used in the same code. It shouldn't be a problem to write a program to generate headers with such definitions. Or even better a preprocessor that would take all these words and convert them to a format in which they are all the same.
I see a bright future ahead of us..

[wolfgang]

Just because I can:
EDIT, Fixed small errors.

#include <ctime>
#include <vector>
#include <string>
#include <fstream>
#include <iostream>
#include <iterator>

#include <boost/random/uniform_int.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/variate_generator.hpp>

// Global Gen Var
boost::mt19937 gen;

// Prototype
int rand (int, int);
void get_words (std::vector<std::string> &);
void jumble (std::vector<std::string> &);
  void jumble (std::string &);
  void swap (char &, char &);
void print (const std::vector<std::string> &);


int main ()
{
  gen.seed( (unsigned)std::time(0) );

  std::vector<std::string> sentence;
  get_words(sentence);
  jumble(sentence);
  print(sentence);
}

int rand(int min, int max)
{
  boost::uniform_int<> dist(min, max);
  boost::variate_generator< boost::mt19937&, boost::uniform_int<> > rnd(gen, dist);
  return rnd();
}

void get_words (std::vector<std::string> &words)
{
  std::ifstream fin("jumble.txt");
  if (!fin)
  {
    std::cerr << "Cannot find file \'jumble.txt\'. Please check directory.";
    //throw std::invalid_argument;
  }

  std::string temp;
  while ( fin >> temp )
  {
    words.push_back(temp);
  }

  fin.close();
  return;
}

void jumble (std::vector<std::string> &words)
{
  for (std::vector<std::string>::iterator it = words.begin();
        it != words.end(); ++it)
  {
    if (it->length() > 2)
      jumble(*it);
  }

  return;
}

void jumble (std::string &str)
{
  for (size_t i = 0; i < str.length()-1; ++i)
  {
    size_t k = rand(1, str.length()-2), j = rand(1, str.length()-2);
    if ( k != j )
      swap(str[k], str[j]);
  }

  return;
}

void swap(char &a, char &b)
{
  char temp = a;
  a = b;
  b = temp;

  return;
}

void print (const std::vector<std::string> &words)
{
  std::ostream_iterator<std::string> out_it (std::cout, " ");
  std::copy ( words.begin(), words.end(), out_it );

  return;
}

[Browni3141]

Now we just need a program to jumble its own source code. :-)

[ultifinitus]

I see a bright future ahead of us..

Oh fine, be pessimistic ;)

Perhaps he should just make his own jumbled IDE? Call it jIDE? Maybe he should swap around his ascii codes, you know make it reeeeaaaly confusing? Or even better he should just parse only the first and last letter of every keyword so you can literally type anything as long as the first and last letters were the same? Do you see your world darkening by the poorly worded suggestion?

[ne555]

Or even better a preprocessor that would take all these words and convert them to a format in which they are all the same.

if(s.size()>1) std::sort( s.begin()+1, s.end()-1 );

[thomas430]

I love where this thread is going :P