void Table::addRow2(class Database& db,string table_name,int no_of_columns) {
/* int no;
for ( db.it = db.mymap.begin(); db.it != db.mymap.end(); db.it++)
{
for(db.t = db.it->second.table.begin(); db.t!=db.it->second.table.end(); ++db.t)
{
no = db.t->size();
cout << no;
}
} */
vector<string> myvector(no_of_columns,"000");
if (db.mymap.count(table_name)>0)
{
db.it=db.mymap.find(table_name);
db.it->second.table.push_back(myvector);
}
else
cout << "table doesn't exist! \n";
}
int main () {
int i;
int myints[] = {32,71,12,45,26,80,53,33};
int myint[] = {32,71,12,45,26,80,53,33};
std::vector<int> myvector (myints, myints+8); // 32 71 12 45 26 80 53 33
std::sort (myints,myints+8);
for(i=0;i<8;i++)
std::cout << ' ' << myints[i];
std::cout << '\n';
std::sort (myint,myint+8,myfunction);
for(i=0;i<8;i++)
std::cout << ' ' << myint[i];
std::cout << '\n';
// using default comparison (operator <):
std::sort (myvector.begin(), myvector.begin()+4); //(12 32 45 71)26 80 53 33
// using function as comp
std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
// using object as comp
std::sort (myvector.begin(), myvector.end(), myobject); //(12 26 32 33 45 53 71 80)
// print out content:
std::cout << "myvector contains:";
for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
getch();
return 0;
}
void Table::addRow(class Database& db,int rowIndex,string table_name) {
/* int no;
for ( db.it = db.mymap.begin(); db.it != db.mymap.end(); db.it++)
{
for(db.t = db.it->second.table.begin(); db.t!=db.it->second.table.end(); ++db.t)
{
no = db.t->size();
cout << no;
}
} */
cout << "Enter the row name: ";
string txt;
cin >> txt;
vector<string> myvector(db.column_names[table_name].size(),"000");
if (db.mymap.count(table_name)>0)
{
db.row_names[table_name].insert(db.row_names[table_name].begin() + rowIndex, txt);
db.it=db.mymap.find(table_name);
db.it -> second.table.insert(db.it->second.table.begin()+ rowIndex, myvector);
}
else
cout << "table doesn't exist! \n";
}
int main () {
int myints[] = {32,71,12,45,26,80,53,33};
printf("sizeof(myints) %d \n",sizeof(myints)/sizeof(*myints));
printf("original: \n");
int i;
for (i = 0; i <sizeof(myints)/sizeof(*myints); i++) {
printf("%d ",myints[i]);
}
std::cout<<std::endl;
std::vector<int> myvector (myints, myints+8); // 32 71 12 45 26 80 53 33
// using default comparison (operator <):
//std::sort (myvector.begin(), myvector.begin()+4); //(12 32 45 71)26 80 53 33
// using function as comp
//std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
// using object as comp
std::sort (myvector.begin(), myvector.end(), myobject); //(12 26 32 33 45 53 71 80)
// print out content:
std::cout << "myvector contains:\n";
for (std::vector<int>::iterator it =myvector.begin(); it!=myvector.end(); ++it)
std::cout << *it << ' ' ;
std::cout << '\n';
return 0;
}
int main () {
// counting elements in array:
int myints[] = {10,20,30,30,20,10,10,20}; // 8 elements
int mycount = std::count (myints, myints+8, 10);
std::cout << "10 appears " << mycount << " times.\n";
// counting elements in container:
std::vector<int> myvector (myints, myints+8);
mycount = std::count (myvector.begin(), myvector.end(), 20);
std::cout << "20 appears " << mycount << " times.\n";
return 0;
}
int main(){
TissueCell::Vector myvector(100);
MTRand rng;
std::generate(myvector.begin(), myvector.end(), [&rng]() -> TissueCell::Unit
{return TissueCell::Unit::CreateRandom(rng);} );
for (auto& cell : myvector){
std::cout << "Random x position: " << cell.x << std::endl;
}
}
void tc_shrink_to_fit()
{
std::cout << "-----\t shrink_to_fit" << '\n';
MySTL::vector<int> myvector(100);
std::cout << "1. capacity of myvector: " << myvector.capacity() << '\n';
myvector.resize(10);
std::cout << "2. capacity of myvector: " << myvector.capacity() << '\n';
//myvector.shrink_to_fit();
//std::cout << "3. capacity of myvector: " << myvector.capacity() << '\n';
}
void tc_at()
{
std::cout << "-----\t at" << '\n';
MySTL::vector<int> myvector(10); // 10 zero-initialized ints
// assign some values:
for (unsigned i = 0; i < myvector.size(); i++)
myvector.at(i) = i;
std::cout << "myvector contains:";
printvector(myvector);
}
int main() {
Solution *s = new Solution();
int myints[] = {1, 3, 2};
std::vector<int> myvector (myints, myints + sizeof(myints) / sizeof(int) );
s->nextPermutation(myvector);
for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it){
std::cout << ' ' << *it;
}
std::cout << '\n';
return 0;
}
int main(){
int myints[]={10,20,30,30,20,10,10,20};
std::vector<int> myvector(myints, myints+8);
std::replace(myvector.begin(), myvector.end(), 20,99);
std::cout << "myvector contains:";
for(std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << std::endl;
return 0;
}
int main ()
{
std::vector<int> myvector (100);
std::cout << "1. capacity of myvector: " << myvector.capacity() << '\n';
myvector.resize(10);
std::cout << "2. capacity of myvector: " << myvector.capacity() << '\n';
myvector.shrink_to_fit();
std::cout << "3. capacity of myvector: " << myvector.capacity() << '\n';
return 0;
}
// iterator
void tc_iterators()
{
std::cout << "-----\t iterators" << '\n';
MySTL::vector<int> myvector(5); // 5 default-constructed ints
auto i = 0;
//MySTL::vector<int>::reverse_iterator rit = myvector.rbegin();
//for (; rit != myvector.rend(); ++rit)
// *rit = ++i;
std::cout << "myvector contains:";
printvector(myvector);
}
int main ()
{
std::vector<int> myvector(8); // myvector: 0 0 0 0 0 0 0 0
std::fill (myvector.begin(), myvector.begin() + 4, 5); // myvector: 5 5 5 5 0 0 0 0
std::fill (myvector.begin() + 3, myvector.end() - 2, 8); // myvector: 5 5 5 8 8 8 0 0
std::cout << "myvector contains:";
for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
int main () {
int myints[] = {32,71,12,45,26,80,53,33};
std::vector<int> myvector (myints, myints+8); // 32 71 12 45 26 80 53 33
// using function as comp
std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
// print out content:
std::cout << "myvector contains:";
for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
void RandomVectorTest(){
TissueCell::Vector myvector(100);
MTRand rng;
std::generate(myvector.begin(), myvector.end(), [&rng]() -> TissueCell::Unit
{return TissueCell::Unit::CreateRandom(rng);} );
for (auto& cell : myvector){
assert(cell.x <= 1 && cell.x >= 0);
assert(cell.y <= 1 && cell.y >= 0);
assert(cell.angle <= 1 && cell.angle >= 0);
}
assert(myvector.size() == 100);
}
void tc_data()
{
std::cout << "-----\t data" << '\n';
MySTL::vector<int> myvector(5);
int* p = myvector.data();
*p = 10;
++p;
*p = 20;
p[2] = 100;
std::cout << "myvector contains:";
printvector(myvector);
}
void Stack_Practice::Test_Constructor()
{
std::deque<int> mydeque (3,100); // deque with 3 elements
std::vector<int> myvector (2,200); // vector with 2 elements
std::stack<int> first; // empty stack
std::stack<int> second (mydeque); // stack initialized to copy of deque
std::stack<int,std::vector<int> > third; // empty stack using vector
std::stack<int,std::vector<int> > fourth (myvector);
std::cout << "size of first: " << first.size() << '\n';
std::cout << "size of second: " << second.size() << '\n';
std::cout << "size of third: " << third.size() << '\n';
std::cout << "size of fourth: " << fourth.size() << '\n';
}
int jump(int A[], int n) {
if(n==0) return 0;
vector<int> myvector(n,0);
int max=0;
for(int i=0;i<n&&max<n;i++){
if(i+A[i]<= max) continue;
else{
for(int j=max+1;j<n&&j<=i+A[i];j++){
myvector[j]=myvector[i]+1;
}
max=i+A[i];
}
}
return myvector[n-1];
}
int main()
{
int A[] = {1, 4, 6,8,10,45};
std::vector<int> myvector (A, A+6);
std::sort(myvector.begin(), myvector.end());
int n = 16;
int arr_size = 6;
int r = hasPairWithSum1(A,n, arr_size);
if(r)
printf("Yes it is !!!\n");
else
printf("No\n");
getchar();
return 0;
}
int main () {
int myints[] = {32,71,12,45,26,80,53,33};
std::vector<int> myvector (myints, myints+8); // 32 71 12 45 26 80 53 33
// using default comparison (operator <):
std::sort (myvector.begin(), myvector.end()); //(12 32 45 71)26 80 53 33
std::sort (myvector.begin()+4, myvector.end(), compareFunction); // 12 32 45 71(26 33 53 80)
// using object as comp
std::sort (myvector.begin(), myvector.end(), compareObject); //(12 26 32 33 45 53 71 80)
for (std::vector<int>::iterator i=myvector.begin(); i!=myvector.end(); i++)
std::cout << ' ' << *i;
return 0;
}
vector<int> twoSum(vector<int> &numbers, int target) {
vector<int> myvector(2,0);
map<int,int> mymap;
int temp;
for(int i=0;i<numbers.size();i++){
temp=target-numbers[i];
if(mymap.find(temp)!=mymap.end()){
myvector[0]=mymap[temp]+1;
myvector[1]=i+1;
return myvector;
}
else{
mymap[numbers[i]]=i;
}
}
return myvector;
}
int main() {
int myints[] = { 32,71,12,45,26,80,53,33 };
std::vector<int> myvector(myints, myints + 8); // 32 71 12 45 26 80 53 33
std::sort(myvector.begin(), myvector.begin() + 4); //(12 32 45 71)26 80 53 33
std::sort(myvector.begin() + 4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
std::sort(myvector.begin(), myvector.end(), myobject); //(12 26 32 33 45 53 71 80)
std::cout << "myvector contains:";
for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << std::endl;
return 0;
}
int main () {
int myints[]={10, 20, 30, 40, 50, 60, 70};
std::vector<int> myvector(7);
std::vector<int> myvector2(5);
//copy 不能插入空的容器中
std::copy(myints, myints+7, myvector.begin()); //reverse_copy
std::cout << "myvector contains:";
for (auto item : myvector)
std::cout << item << " ";
std::cout <<std::endl;
std::copy_n(myints, 5, myvector2.begin());
std::cout << "myvector2 contains:";
for (auto item : myvector2)
std::cout << item << " ";
std::cout <<std::endl;
std::vector<int> foo = {25, 15, 5, -5, -15};
std::vector<int> bar(foo.size());
// copy only positive numbers:
auto it = std::copy_if(foo.begin(), foo.end(), bar.begin(), function);
bar.resize(std::distance(bar.begin(), it)); // shrink container to new size
std::cout << "bar contains:";
for (auto x: bar)
std::cout << x << " ";
std::cout << std::endl;
std::vector<int> a;
for (int i=1; i<10; ++i) a.push_back(i); // 1 2 3 4 5 6 7 8 9
std::reverse(a.begin(), a.end()); // 9 8 7 6 5 4 3 2 1
std::cout << "a contains:";
for (auto x: a)
std::cout << x << " ";
std::cout << std::endl;
return 0;
}
int main () {
int myints[] = {9,8,7,6,5,4,3,2,1};
std::vector<int> myvector (myints, myints+9);
// using default comparison (operator <):
std::partial_sort (myvector.begin(), myvector.begin()+5, myvector.end());
std::cout << "use default, myvector contains:";
for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
// using function as comp
std::partial_sort (myvector.begin(), myvector.begin()+5, myvector.end(),myfunction);
// print out content:
std::cout << "use usrfunc, myvector contains:";
for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
// element access
void tc_elementAccess()
{
std::cout << "-----\t element access" << '\n';
MySTL::vector<int> myvector(10); // 10 zero-initialized elements
MySTL::vector<int>::size_type sz = myvector.size();
// assign some values:
for (unsigned i = 0; i < sz; i++) myvector[i] = i;
// reverse vector using operator[]:
for (unsigned i = 0; i < sz / 2; i++)
{
int temp;
temp = myvector[sz - 1 - i];
myvector[sz - 1 - i] = myvector[i];
myvector[i] = temp;
}
std::cout << "myvector contains:";
printvector(myvector);
}
void tc_insert()
{
std::cout << "-----\t insert" << '\n';
MySTL::vector<int> myvector(3, 100);
MySTL::vector<int>::iterator it;
it = myvector.begin();
it = myvector.insert(it, 200);
myvector.insert(it, 2, 300);
// "it" no longer valid, get a new one:
it = myvector.begin();
MySTL::vector<int> anothervector(2, 400);
myvector.insert(it + 2, anothervector.begin(), anothervector.end());
int myarray[] = { 501, 502, 503 };
myvector.insert(myvector.begin(), myarray, myarray + 3);
std::cout << "myvector contains:";
printvector(myvector);
}
int main(){
int myints[]={10,20,20,20,30,30,20,20,10};
std::vector<int> myvector(9);
// using default compairson:
std::vector<int>::iterator it;
it=std::unique_copy(myints, myints+9, myvector.begin());
std::sort(myvector.begin(), it);
// using predicate comparison:
it=std::unique_copy(myvector.begin(), it, myvector.begin(), myfunction);
myvector.resize(std::distance(myvector.begin(), it));
// print out content:
std::cout << "myvector contains:";
for(it=myvector.begin(); it!=myvector.end(); ++it)
std::cout << ' ' << *it;
std::cout << std::endl;
return 0;
}
int main(){
int myints[]={10,20,30,30,20,10,10,20};
std::vector<int> myvector(myints, myints+8);
std::vector<int>::iterator it;
// using default comparison:
it = std::search_n(myvector.begin(), myvector.end(), 2, 30);
if(it != myvector.end())
std::cout << "two 30s found at position " << (it-myvector.begin()) << std::endl;
else
std::cout << "match not found." << std::endl;
// using predicate comparison:
it = std::search_n(myvector.begin(), myvector.end(), 2, 10, mypredicate);
if(it != myvector.end())
std::cout << "two 10s found at position " << int(it-myvector.begin()) << std::endl;
else
std::cout << "match not found." << std::endl;
return 0;
}
int main () {
// using std::find with array and pointer:
int ints[] = { 10, 20, 30, 40 };
std::vector<int> myvector(ints, ints+4);
std::vector<int>::iterator ret;
try {
ret = easyfind< std::vector<int> >(myvector, 30);
std::cout << "value " << *ret << " found in vector" << std::endl;
}
catch (ValueNotFound & e) {
std::cout << e.what() << std::endl;
}
try {
ret = easyfind< std::vector<int> >(myvector, 3);
std::cout << "value " << *ret << " found in vector" << std::endl;
}
catch (ValueNotFound & e) {
std::cout << e.what() << std::endl;
}
return 0;
}
void testCase5()
{
tsVec<int> myvector(5); // 5 default-constructed ints
int i = 0;
tsVec<int>::reverse_iterator rit = myvector.rbegin();
for (; rit != myvector.rend(); ++rit) {
*rit = ++i;
}
i = 5;
for (tsVec<int>::iterator it = myvector.begin(); it != myvector.end();
++it, --i) {
assert(*it == i);
}
i = 1;
for (tsVec<int>::reverse_iterator it = myvector.rbegin(); it != myvector.rend();
++it, ++i) {
assert(*it == i);
}
}
