---

#include <iostream>using namespace std;


bool esMisterioso(int n)
{
    bool esMisterioso = false;
    int c = 0;
    for ( int i = 1; i <= n; i++)
    {
        if ( n % i == 0 ) c++;
    }
   
    if ( n % c == 0 ) esMisterioso = true;
   
    return esMisterioso;
}


int main()
{
    int a, b, num = 0;
    cin >> a >> b;
    for ( int i = a; i <= b; i++)
    {
        if ( esMisterioso(i) ) num++;
    }
    cout << num;
    return 0;
}

---

---


#include <stdio.h>     
#include <stdlib.h> 
#include <iomanip>
#include <fstream>
#include <iostream>
 #include <cstring>
#include <sstream>
#include <string>
#include <string.h>


#include <vector>
#include <map>


using namespace std;




map<string, int> testMap;


int main()
{   
   


    testMap["a"]=4;
    testMap["b"]=5;
    testMap["c"]=6;
    testMap["d"]=7;
    testMap["e"]=8;
    testMap["f"]=9;
    testMap["g"]=10;
    testMap["h"]=11;
    testMap["k"]=12;
    testMap["l"]=13;
   
    vector<string> vec_st;
       
   
    vec_st.push_back("a");
    vec_st.push_back("b");
    vec_st.push_back("c");
    vec_st.push_back("d");
    vec_st.push_back("e");
    vec_st.push_back("f");
    vec_st.push_back("g");
    vec_st.push_back("h");
    vec_st.push_back("k");
    vec_st.push_back("l");


   
       
    int firstSize = testMap.size();
    cout << "Before the search for missing key m, we have testMap.size() = " << firstSize << endl;
    cout << "Values of the map before the attempt to look up missing key: " << endl;
    for(int i=0; i < testMap.size(); i++)
    {
        cout << "testMap[vec_st["<<i<<"] ] = " << testMap[vec_st[i] ] << endl;
    }
   
    string s = "m";
    int j2 = testMap[s] ; // Questionable attempt to find a missing key's value
    cout << "s = " << s << " , but after this questionable lookup of s, we get testMap[s] = " << j2 << endl;


    int secondSize = testMap.size();
    cout << "Size AFTER the search for missing key m = " << secondSize << endl;
    cout << " After the attempt to look up a missing key we get: " << endl;


    for(int i=0; i< testMap.size(); i++)
    {
        cout << "testMap[vec_st["<<i<<"] ] = " << testMap[vec_st[i] ]<< endl;
    }


    // Better safeguard: use the ::count() function to check that the key exists in the first place:
    // Write: if(testMap.count(s) >0) { j2=testMap[s] ; }
   


}

---

---

class moClassValueContainer {
public:
        moClassValueContainer();
        moClassValueContainer(string,int);
        string        name;
        int                maxNodeCount;
        vector<string> headerFields;
};
typedef enum {SINGLE,LIST} valueType; // this is C style
class Container {
        public:
                Container (xml_node n);
                valueType getType() { return type; }     
                vector< vector<string> > getListNames();   
                vector< vector<string> > getListValues(); 
                string getListElement(string n);               
                string getName();                         
                string getValue();                       
                int getElementCount();                   
        private:
                valueType type;
                xml_node node;
                int count;      // for list only, otherwise count = 0
                int itemNo;
                string name;
                string moClass;
                vector< vector<string> > listNames;
                vector< vector<string> > listValues;
                void analyseList();
                bool listAnalyzed;
};

Container::Container(xml_node n) {
        node = n;
        itemNo = 0;
        listAnalyzed = false;
        name = string(node.attribute("name").value());
        if (!string(node.name()).compare("list")) {
                type = LIST;
                count = 0;
        } else {
                type = SINGLE;
                count = 1;
        }
}

string Container::getName() {
        if (type == SINGLE)
                return name;
        else
                return "";
}

---

---


for (xml_node tnode = it->first_child(); tnode ; tnode = tnode.next_sibling()) {
        Container tmpContainer(tnode);
        if (tmpContainer.getType() == SINGLE) {
                string t = tmpContainer.getName();
                moClassValueContainerVector[k].headerFields.push_back(t);
      } else {
                ....
                ....
      }
}

---

---

char *aps[5] = {{"aps zero "}, {"aps one  "}, {"aps two  "},
                {"aps three"}, {"aps four "}};

---

---

#include <iostream>
#include <string>

using namespace std;

int main()
{
char input[300], *p, *q[300], **r = q;

 cin.getline(input, 300);

 for (p = input; *p; p++)
  switch (tolower(*p)) {
  case 'e':
    *r++ = p;
    break;
  case '.':
  case '\'':
  case ' ':
    *p = '\0';
    break; }
 *r = 0;

 for (r = q; *r; r++)
  cout << *r << " ";

 cout << endl;
}

---

---

#ifndef __CUSTOM_ALLOCATOR_H__
#define __CUSTOM_ALLOCATOR_H__

#include <assert.h>
#include <limits.h>

template<class T>
class Custom_Allocator
{

public:

  typedef T value_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef const T* const_pointer;
  typedef T& reference;
  typedef const T& const_reference;

  Custom_Allocator( signed char *pool, int nPoolSize )
  {
    Init();
    m_pool = pool;
    m_nPoolSize = nPoolSize;
  }

  Custom_Allocator( int n )
  {
    Init();
  }

  Custom_Allocator()
  {
    Init();
  }

  void Init()
  {
    m_pool = 0;
    m_nPoolSize = 0;
    g_nCnt = 0;
    g_nTot = 0;
  }

  Custom_Allocator( const Custom_Allocator &obj ) // copy constructor
  {
    Init();
    m_pool = obj.m_pool;
    m_nPoolSize = obj.m_nPoolSize;

  }

private:

  long g_nCnt; // total # blocks allocated
  long g_nTot; // total allocated

  void operator =( const Custom_Allocator & );

public:

  signed char *m_pool;
  unsigned m_nPoolSize;

  template<class _Other>
  Custom_Allocator( const Custom_Allocator< _Other > &other )
  {
    Init();
    m_pool = other.m_pool;
    m_nPoolSize = other.m_nPoolSize;
  }

  ~Custom_Allocator()
  {

  }

  template<class U>
  struct rebind
  {
    typedef Custom_Allocator< U > other;
  };

  pointer  address( reference r ) const
  {
    return &r;
  }

  const_pointer address( const_reference r ) const
  {
    return &r;
  }

  pointer allocate( size_type n, const void* /*hint*/= 0 )
  {
    pointer p = 0;
    unsigned nSize = n * sizeof(T);

    if( m_pool ) // if we have a mem pool from which to allocated
    {
      p = (pointer) m_pool;// just return the next available mem in the pool

      if( g_nTot + nSize > m_nPoolSize )
      {
        assert( 0 );//,"out of mem pool");
        return 0;
      }

      m_pool += nSize; // and bump the pointer
    }
    else
    {
//      p = (pointer) malloc( nSize );// no pool: just use malloc
    }

    g_nCnt += 1;
    g_nTot += nSize;
    assert( p );

    return p;
  }

  void deallocate( pointer p, size_type /*n*/)
  {
//    if( !m_pool )// if there's a pool, nothing to do
//    {
//      free( p );
//    }
  }

  void construct( pointer p, const T& val )
  {
    new (p) T( val );
  }

  void destroy( pointer p )
  {
    p->~T();
  }

  size_type max_size() const
  {
    return ULONG_MAX / sizeof(T);
  }
};

template<class T>
bool operator==( const Custom_Allocator< T >& left, const Custom_Allocator< T >& right )
{
  if( left.m_pool == right.m_pool )
  {
    return true;
  }
  return false;
}

template<class T>
bool operator!=( const Custom_Allocator< T >& left, const Custom_Allocator< T >& right )
{
  if( left.m_pool != right.m_pool )
  {
    return true;
  }

  return false;
}
#endif

---

---

#ifndef __CONTAINER_H__
#define __CONTAINER_H__
#include <boost/unordered_map.hpp>
#include <Custom_Allocator.h>

using namespace std;
using namespace __gnu_cxx;

template<float const &threshold> class compare_float {
  public:
    compare_float() : m_d(threshold){}
    inline bool operator()(const float &x, const float &y) const { return ((x + m_d) < y); }// return abs(abs(x)-abs(y))<m_d; }
    float m_d;
};

class Container
{
public:
  static const float map_threshold;

  Container();

private:
  typedef Custom_Allocator<std::pair<float, float> > MyAllocator;
  boost::unordered_map<float, float, boost::hash<float>, compare_float<map_threshold>, MyAllocator >map_test;
  static const float c_max_key = 10.0f;
  static const float c_min_key = -10.0f;
};
#endif

---

---

#include <Container.h>
#include <stdio.h>

const float Container::map_threshold = .001f;
signed char map_pool[sizeof(float)*3000];

Container::Container() : map_test(MyAllocator(map_pool, sizeof(map_pool)))
{
  for(float i = c_min_key; i < c_max_key + .1f; i += .1f)
  {
        printf("Storing: %f => %f.\n", i, (i*1000.0f));
    map_test[i] = i*1000.0f;
    printf("Stored:  %f => %f.\n", i, map_test[i]);
    printf("++++++++++++++++++++++++++++++\n");
  }

  printf("=====================================\n");

  printf("%f.\n", map_test[1.2f]);
  printf("%f.\n", map_test[-1.2f]);
  printf("%f.\n", map_test[6.2f]);
  printf("%f.\n", map_test[-13.2f]);
  printf("%f.\n", map_test[.2f]);
}

---

---

#include <Container.h>

int main()
{
        Container c;

        return 0;
}

---

---

#define MAXF 20000    //max num of friends
#define MAXC 1000000    //max num of connections between them
#define MAXL 20    //max num of girls we are interested
#define MAXB 100000000    //max budget


int main()
{
    int budget;
    cin >> budget;    cin.get();


    int friendsCnt;
    cin >> friendsCnt;    cin.get();
    string friends[MAXF];
    friends[0] = "Tvrtko";
    for(int i = 1; i < friendsCnt+1; i++)
    {
        getline(cin, friends[i]);
    }


    int loversCnt;
    cin >> loversCnt;    cin.get();
    string lovers[MAXL];
    for(int i = 0; i < loversCnt; i++)
    {
        int tmp;
        cin >> tmp;    cin.get();
        lovers[i] = friends[tmp];
    }


    int connectionsCnt;
    cin >> connectionsCnt;    cin.get();
    for(int i = 0; i < connectionsCnt; i++)
    {
        int indexF, indexC, price;
        cin >> indexF >> indexC >> price;    cin.get();
    }
    return 0;
}

---

---

#include <iostream>
using namespace std;

int addMultiples()
{
  // Start
  cout << "What multiples are we adding? ";
  int start;
  cin >> start;

  int increment = start;

  for (int count = start; count <= 100; count += increment)
  cout << "The sum of multiples of " << start
        << " less than 100 are: " << count << endl;

  return 0;
}




int main()
{
  addMultiples();
  return 0;
}

---

---

struct masternode* lexical_scanner(ifstream* inputfile) {
    string word;
    char c;
    struct masternode* root = NULL;
    while (c!=EOF){
        if((c = (*inputfile).get()) != ' ' && c != ':' && c!= ';' && c!='\n')
            word += c;
        root = insert(root, word);
        word.clear();
    }
    return root;
}

---

---

//in header
BVH_Node* bvh;
//in main raytrace function
bvh = new BVH_Node(objList,0);

---

---

//here's how the beginning of it looks
BVH_Node::BVH_Node(vector<GeomObj*> list, int axis){
  int size = list.size(); //number of elements in list
  this->isObj = false;
  if(size == 1){
    this->left = makeLeaf(list[0]);
    this->right = makeLeaf(NULL);
    this->bb = list[0]->bb;
    return;
  }
  if(size == 2){
    this->left = makeLeaf(list[0]);
    this->right = makeLeaf(list[1]);
    this->bb = combineBoxes(list[0]->bb,list[1]->bb);
    return;
  }
//the rest of it
}

---

---

BVH_Node* BVH_Node::makeLeaf(GeomObj* v){
  BVH_Node* node;
  node->obj = v;
  node->isObj = true;
  return node;
}

---

---

node->obj = v;

---

---

time1.h

#pragma once
class time1
{
public:
time1(int=0, int=0, int=0);
void setTime(int, int, int);
void printMilitary();
void printStandard();
~time1(void);
private:
    int hour, minute, second;
   

   
};

---

---

time1.cpp

#include "time1.h"
#include <iostream>
using namespace std;

time1::time1(int hr, int min, int sec)
{
    setTime(hr, min, sec);
}

void time1::setTime(int h, int m, int s)
{
    hour=  (h>=0 && h<24) ? h:0;
    minute=(m>=0 && m<60) ? m:0;
    second=(s>=0 && s<60) ? s:0;
}

void time1::printMilitary()
{
    cout<< (hour<10 ? "0" : "") << hour << ":"
        << (minute <10 ? "0" : "")<<minute;
       
}

void time1::printStandard()
{
    cout<< ((hour==0 || hour==12) ? 12 : hour % 12)
        << ":" << (minute < 10 ? "0" : "") << minute
        << ":" << (second < 10 ? "0" : "") <<second
        <<(hour < 12 ? " AM" : " PM");
}
time1::~time1(void)
{
}

---

---

source file source.cpp

#include<iostream>
#include"time1.h"
using namespace std;
void main()
{
    time1 t1, t2(2), t3(21, 34), t4(12,25, 42), t5(27,74,99);

    cout<< "Default Time: \n";
    t1.printMilitary();
    cout<<endl;
    t1.printStandard();

    cout<< "\n\nHour input, minutes and seconds are default: \n";
    t2.printMilitary();
    cout<<endl;
    t2.printStandard();

    cout<<"\n\nhours and minutes specified, seconds default: \n";
    t3.printMilitary();
    cout<<"\n";
    t3.printStandard();

    cout<<"\n\nEverything is specified: \n";
    t4.printMilitary();
    cout<<endl;
    t4.printStandard();

    cout<<"\n\nall invalid values given: \n";
    t5.printMilitary();
    cout<<endl;
    t5.printStandard();
    cout<<endl;
    system("pause");

   

}

---