ITT: Sepples

#include <iostream>
using namespace std;

class hurr {
    public:
        int a, b;
        hurr() {
            a = 4;
            b = 8;
        }
};
class hurf {
    public:
        hurr durr;
};

int main() {
    hurf durf;
    cout << durf.durr.a << endl;
}

#define HAX int
#define MY
#define ANUS main
#define ONE
#define WORD void
#define U printf
#define Lain(x) #x
#define MENA(Xarn) (Lain(Xarn) "\n");
#define HASKAL
#define THE return
#define FORCED MY HASKAL
#define INDENTATION MY HASKAL
#define OF MY ONE HASKAL INDENTATION
#define CODE 0

HAX MY ANUS (ONE WORD) {
    HAX MY anus;
    U MENA (HASKAL);
    THE FORCED INDENTATION OF CODE;
}

<code>
#include <iostream>

#define LOWER 1
#define UPPER 30
#define SIZE  1000000
#define SEARCH 10

int rank_of(int number)
{   
      int rank=1;
      while(number>=10)
      {
              rank++ ;
              number/=10;
     }       
      return rank;
}

void tab_number(int number, int max=UPPER)
{
       for(int i=0; i<rank_of(max)-rank_of(number);i++)
           std::cout<<" ";
      std::cout<<number;         
}
 
            
struct Tree
{
     int value, quant;
     Tree *left, *right; 
    
      Tree(int v)
     {    
                value=v;
           quant=1;
           left =0;
           right=0;    
     } 
         
     void insert(int v)
     {    
                if(v<value)
           {   if(!left)
                         left=new Tree(v);
                      else  
                         left->insert(v);
                      return;
           }
           if(v>value)
           {   if(!right)
                         right=new Tree(v);
                      else  
                         right->insert(v);
                      return;
           }
              quant++;
           return;
     }
             
     int search(int v)               
     {    
              if(v<value)
           {   if(!left)
                         return 0;
                      else  
                         return(left->search(v));
           }
           if(v>value)
           {   if(!right)
                         return 0;
                      else  
                         return(right->search(v));
           }
           return quant;
     }
     
      void find_branch(int v, Tree *& mem)               
     {    
              if(v<value)
           {   if(!left)
                         return;
                      else  
                         return(left->find_branch(v, mem));
           }
           if(v>value)
           {   if(!right)
                         return;
                      else  
                         return(right->find_branch(v, mem));
           }
           mem=this;
     }    
    
     void print(int repeat=1)
     {  
              std::cout<<"\n"
                     <<"\t\t  [  ";
                          tab_number(value);
              std::cout<<"  ] - ( "<<quant<<" )\n" ;
                    
            if(!left&&!right)
                    std::cout<<"\n\n";
              else
              {     std::cout<<"\t\t  "<<"/"<<"      \\\n"
                            <<"\t\t[";
                     
                          if(left)
                              std::cout<<left->value;
                       else
                              std::cout<<"  ";
                                                       
                      std::cout<<"]\t[";
                     
                          if(right)
                              std::cout<<right->value;
                       else
                              std::cout<<"  ";
                               
                      std::cout<<"]\n";  
               }
           if(!repeat)
                     return;        
              
           if (left)
                    left->print();
           if (right)
                    right->print();        
      }
};
      
class BST
{   
      Tree *root; 
  public:
              
     BST()
      {    root=0;}
    
     void insert(int v) 
     {
               if(!root)
              root=new Tree(v);          
          else
                 root->insert(v);  
     }
     
     int search(int v)
     {
           std::cout<<"\n[ ";
                tab_number(v);
               std::cout<<" ] - ( "<<(root->search(v))<<" )";            
     }
    
     void print(int v=0)
     {    std::cout<<"\n----------------------------------------------------------------";
             Tree *top=root;
               if(v)
               {
                       if(root->search(v))
                       {
                         root->find_branch(v, top);
                       std::cout<<"\nPrinting branches starting from ["<<top->value<<"]:\n";
                     }
                     else
                     { 
                          std::cout<<"\nNo value ["<<v<<"] to be found in current tree.\n";
                         return;
                     }   
             }
             else     
                     std::cout<<"\nPrinting tree from root:\n";
                    
               top->print(0);
                       
             if(top->left)
             {
                     std::cout<<"\n\nLeft branches:\n";
                  top->left->print();
             }
             if(top->right)
             {        
                  std::cout<<"Right branches:\n";
                  top->right->print();
             }        
     } 
};


int main()
{   srand(time(0));
    


     BST oak;

    for(int i=0;i<SIZE;i++)
          oak.insert(rand()%UPPER+LOWER);

    oak.print();
    oak.print(rand()%UPPER+LOWER);
    oak.print(rand()%UPPER+LOWER);
    oak.print(99);
    
     for(int i=LOWER;i<UPPER;i++)
          if((rand()%100+1)<SEARCH)
            oak.search(i);
     oak.search(313);   
       
           
     std::cout<<std::endl;
     system("PAUSE");
 
    return 0;
}

Thanks for your homework >>3-san. Now I have something to submit for the same assignment I'm doing.

>>4
You may fail it.

>>2
So what is the Lain of Xarn?

>>2

int main ( void) {
 int anus;
 printf ("" "\n");;
 return 0;
}

>>7
No.


int main (void) {
    int anus;
    printf ("HASKAL\n");
    return 0;
}