Vectors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vectors\n",
    "\n",
    "## Topics\n",
    "- what is and why vectors\n",
    "- how to use vectors\n",
    "- various operations and methods provided by vectors\n",
    "- applications and examples using vectors\n",
    "- sorting vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors\n",
    "- vector is a collection of values where each value is identified by a number (index)\n",
    "- anything that can be done by C-array (Array chapter) can be done using vectors\n",
    "    - unlike C-array, vector is an advanced type like C++ string\n",
    "- vector is defined in the C++ Standard Template Library (STL)\n",
    "    - vector is one of my containers library - https://en.cppreference.com/w/cpp/container\n",
    "    - array, set, map, queue, stack, priority_queue are some other containers provided in STL\n",
    "- learning vector is similar to learning C++ string container\n",
    "    - main difference is vector can store any type of element\n",
    "    - learn all the operations provided by vector\n",
    "        - what they are; what they do; how to use them...\n",
    "    - apply vectors to solve problems\n",
    "- vector and other containers provided in STL are templated, hence \"Template\" in STL\n",
    "    - the actual type that you're storing in those containers need to be specified\n",
    "    - very similar to template struct types covered in **Structures** chapter\n",
    "    - to learn STL containers and more, follow these notebooks: https://github.com/rambasnet/STL-Notebooks\n",
    "- must include `<vector>` header to use vector type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vector objects\n",
    "- C++ vector is an advanced type defned in `<vector>` header and the `std namespace`\n",
    "- objects must be instantiated or declared to allocate memory before we can store data into them\n",
    "- since vector uses template type, you must provide the actual type of the data\n",
    "- syntax:\n",
    "\n",
    "```cpp\n",
    "#include <vector>\n",
    "\n",
    "vector<type> objectName;\n",
    "\n",
    "using namespace std;\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "#include <vector>\n",
    "#include <string>\n",
    "#include <sstream>\n",
    "#include <cassert>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "// declare empty vectors\n",
    "vector<string> names;\n",
    "vector<float> tests;\n",
    "vector<int> numbers;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// let's see the contents\n",
    "names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "// declare and initialize vectors\n",
    "vector<string> words = {\"i\", \"love\", \"c++\", \"vectors\"};\n",
    "vector<float> prices = {1.99, 199, 2.99, 200.85, 45.71};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ \"i\", \"love\", \"c++\", \"vectors\" }"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// let's see the contents\n",
    "words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 1.99000f, 199.000f, 2.99000f, 200.850f, 45.7100f }"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing elements\n",
    "- elements accessed mostly using index just like in C-array or string\n",
    "- index starts from 0 and goes to 1 less than the vector size or length\n",
    "- the following methods are available:\n",
    "    - **at(index)** : access specified element with bounds checking\n",
    "    - **operator[index]** : access specified element by index\n",
    "    - **front( )** : access the first element\n",
    "    - **back( )** : access the last element\n",
    "\n",
    "- *do they sound familiar? same method names as accessing characters in string objects*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "love\n",
      "200.85\n",
      "1.99\n",
      "45.71\n"
     ]
    }
   ],
   "source": [
    "// access elements\n",
    "// change i to I in words\n",
    "words[0] = \"I\";\n",
    "cout << words[1] << endl; // print 2nd word\n",
    "cout << prices.at(3) << endl;\n",
    "cout << prices.front() << endl;\n",
    "cout << prices.back() << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Capacity\n",
    "- unlike C-array, vector provides member functions to work with the capacity of the vector objects\n",
    "- the following are the commonly used methods:\n",
    "    - **empty( )** : checks whether the container is empty; returns true if empty; false otherwise\n",
    "    - **size( )** : returns the number of elements or length of the vector\n",
    "    - **max_size( )** : returns the maximum possible number of elements that can be stored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is prices vector empty? false\n",
      "size of words: 4\n",
      "size of prices: 5\n",
      "max size of words: 768614336404564650\n"
     ]
    }
   ],
   "source": [
    "cout << boolalpha; // convert boolean to text true/false\n",
    "cout << \"is prices vector empty? \" << prices.empty() << endl;\n",
    "cout << \"size of words: \" << words.size() << endl;\n",
    "cout << \"size of prices: \" << prices.size() << endl;\n",
    "cout << \"max size of words: \" << words.max_size() << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifiying vectors\n",
    "- vectors once created can be modified using various member functions or methods\n",
    "- some commonly used methods are:\n",
    "    - **clear( )** : clears the contents\n",
    "    - **push_back(element)** : adds an element to the end\n",
    "    - **pop_back( )** : removes the last element\n",
    "\n",
    "- *Note: if C-array was used, programmers would be have to implement these functions*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector<int> age = {21, 34, 46, 48, 46};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 21, 34, 46, 48, 46 }"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// see the initial contents\n",
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's clear age vector\n",
    "age.clear();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// is age cleared?\n",
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// double check!\n",
    "age.empty()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's add element into the empty age vector\n",
    "age.push_back(25);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "age.push_back(39);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_33:2:16: \u001b[0m\u001b[0;1;35mwarning: \u001b[0m\u001b[1mimplicit conversion from 'double' to 'std::__1::vector<int, std::__1::allocator<int> >::value_type'\n",
      "      (aka 'int') changes value from 45.5 to 45 [-Wliteral-conversion]\u001b[0m\n",
      " age.push_back(45.5); // can't correctly add double to int vector\n",
      "\u001b[0;1;32m     ~~~~~~~~~ ^~~~\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "age.push_back(45.5); // can't correctly add double to int vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 25, 39, 45 }"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// let's see the last element\n",
    "age.back()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's remove the last element\n",
    "age.pop_back();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 25, 39 }"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// check if last element is gone\n",
    "age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traversing vectors\n",
    "- similar to string and C-array, vectors can be traversed from the first to last element\n",
    "- can use loop with index or iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I; love; c++; vectors; "
     ]
    }
   ],
   "source": [
    "for(auto val: words)\n",
    "    cout << val << \"; \";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I is 1 characters long.\n",
      "love is 4 characters long.\n",
      "c++ is 3 characters long.\n",
      "vectors is 7 characters long.\n"
     ]
    }
   ],
   "source": [
    "for(int i=0; i<words.size(); i++) {\n",
    "    cout << words[i] << \" is \" << words[i].length() << \" characters long.\" << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators\n",
    "- similar to string iterators, vector provides various iterators \n",
    "- iterators are special pointers that let you manipulate vector\n",
    "- several member function of vector uses iterator to do its operation\n",
    "- let's revist the iterators we went over in string chapter\n",
    "\n",
    "![](resources/range-rbegin-rend.png)\n",
    "\n",
    "- **begin( )** - returns iterator to the first element\n",
    "- **end( )** - returns iterator to the end (past the last element)\n",
    "- **rbegin( )** - returns reverse iterator to the last element\n",
    "- **rend( )** - returns a reverse iterator to the beginning (prior to the first element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I; love; c++; vectors; "
     ]
    }
   ],
   "source": [
    "// let's use iterator to traverse vectors\n",
    "// very similar to using for loop with index\n",
    "for(auto iter = words.begin(); iter != words.end(); iter++)\n",
    "    cout << *iter << \"; \"; // iter is a pointer; so must derefernce to access value pointed to by iter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vectors; c++; love; I; "
     ]
    }
   ],
   "source": [
    "// let's reverse traverse\n",
    "for(auto iter = words.rbegin(); iter != words.rend(); iter++)\n",
    "    cout << *iter << \"; \"; // iter is a pointer; so must derefernce to access value pointed to by iter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aggregagte operations\n",
    "- some aggegate operators such as assignment (=) and comparison (>, ==, etc.) are overloaded and work out of the box on vector objects as a whole\n",
    "- sorta works! - depends on what type of vector and if there's a predfined ordering of values in that type for sorting!\n",
    "- input, output (`<<`, `>>`) operators do not work on vector objects as a whole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "// create words_copy vector with copy assignment\n",
    "vector<string> words_copy = words; // deep copies words into words_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two vectors are equal!"
     ]
    }
   ],
   "source": [
    "// string can be compared out of the box\n",
    "if (words == words_copy)\n",
    "    cout << \"two vectors are equal!\";\n",
    "else\n",
    "    cout << \"two vectors are not equal!\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing vectors to functions\n",
    "- vector can be passed to functions by value or by reference\n",
    "- unless required, it's always efficient to pass containers type such as vectors to function by reference\n",
    "    - copying data can be costly (can take a long time) depending on the amount of data vector is storing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "// given a vector of values find and return average \n",
    "float findAverage(const vector<int> & v) {\n",
    "    float sum = 0;\n",
    "    for (auto val: v)\n",
    "        sum += val;\n",
    "    return sum/v.size();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 25, 39 }"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// let's see the values of age vector\n",
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average age = 32"
     ]
    }
   ],
   "source": [
    "cout << \"average age = \" << findAverage(age);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "// printVector function\n",
    "template<class T>\n",
    "void printVector(const vector<T>& v) {\n",
    "    char comma[3] = {'\\0', ' ', '\\0'};\n",
    "    cout << '[';\n",
    "    for (const auto& e: v) {\n",
    "        cout << comma << e;\n",
    "        comma[0] = ',';\n",
    "    }\n",
    "    cout << \"]\\n\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_52:2:7: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1minvalid operands to binary expression ('std::__1::ostream' (aka 'basic_ostream<char>') and\n",
      "      'vector<std::__1::string>' (aka 'vector<basic_string<char, char_traits<char>, allocator<char> > >'))\u001b[0m\n",
      " cout << words;\n",
      "\u001b[0;1;32m ~~~~ ^  ~~~~~\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:218:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'const void *' for 1st\n",
      "      argument; take the address of the argument with &\u001b[0m\n",
      "    basic_ostream& operator<<(const void* __p);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:194:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'std::__1::basic_ostream<char>\n",
      "      &(*)(std::__1::basic_ostream<char> &)' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:198:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to\n",
      "      'basic_ios<std::__1::basic_ostream<char, std::__1::char_traits<char> >::char_type,\n",
      "      std::__1::basic_ostream<char, std::__1::char_traits<char> >::traits_type>\n",
      "      &(*)(basic_ios<std::__1::basic_ostream<char, std::__1::char_traits<char> >::char_type,\n",
      "      std::__1::basic_ostream<char, std::__1::char_traits<char> >::traits_type> &)' (aka 'basic_ios<char,\n",
      "      std::__1::char_traits<char> > &(*)(basic_ios<char, std::__1::char_traits<char> > &)') for 1st\n",
      "      argument\u001b[0m\n",
      "    basic_ostream& operator<<(basic_ios<char_type, traits_type>&\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:203:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'std::__1::ios_base\n",
      "      &(*)(std::__1::ios_base &)' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&))\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:206:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'bool' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(bool __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:207:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'short' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(short __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:208:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'unsigned short' for 1st\n",
      "      argument\u001b[0m\n",
      "    basic_ostream& operator<<(unsigned short __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:209:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'int' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(int __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:210:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'unsigned int' for 1st\n",
      "      argument\u001b[0m\n",
      "    basic_ostream& operator<<(unsigned int __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:211:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'long' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(long __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:212:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'unsigned long' for 1st\n",
      "      argument\u001b[0m\n",
      "    basic_ostream& operator<<(unsigned long __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:213:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'long long' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(long long __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:214:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'unsigned long long' for 1st\n",
      "      argument\u001b[0m\n",
      "    basic_ostream& operator<<(unsigned long long __n);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:215:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'float' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(float __f);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:216:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'double' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(double __f);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:217:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'long double' for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(long double __f);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:219:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to\n",
      "      'basic_streambuf<std::__1::basic_ostream<char, std::__1::char_traits<char> >::char_type,\n",
      "      std::__1::basic_ostream<char, std::__1::char_traits<char> >::traits_type> *' (aka\n",
      "      'basic_streambuf<char, std::__1::char_traits<char> > *') for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:222:20: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'std::nullptr_t'\n",
      "      (aka 'nullptr_t') for 1st argument\u001b[0m\n",
      "    basic_ostream& operator<<(nullptr_t)\n",
      "\u001b[0;1;32m                   ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:759:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'char' for 2nd argument\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:792:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'char' for 2nd argument\u001b[0m\n",
      "operator<<(basic_ostream<char, _Traits>& __os, char __c)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:799:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'signed char' for 2nd argument\u001b[0m\n",
      "operator<<(basic_ostream<char, _Traits>& __os, signed char __c)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:806:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'unsigned char' for 2nd\n",
      "      argument\u001b[0m\n",
      "operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:820:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'const char *' for 2nd\n",
      "      argument\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:866:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'const char *' for 2nd\n",
      "      argument\u001b[0m\n",
      "operator<<(basic_ostream<char, _Traits>& __os, const char* __str)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:873:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'const signed char *' for 2nd\n",
      "      argument\u001b[0m\n",
      "operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:881:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'const unsigned char *' for\n",
      "      2nd argument\u001b[0m\n",
      "operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1070:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >') to 'const std::__1::error_code'\n",
      "      for 2nd argument\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:752:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: deduced conflicting types for parameter '_CharT' ('char' vs.\n",
      "      'std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>\n",
      "      >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>,\n",
      "      std::__1::allocator<char> > > >')\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:813:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'const _CharT *' against 'vector<std::__1::string>' (aka\n",
      "      'vector<basic_string<char, char_traits<char>, allocator<char> > >')\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1053:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'basic_string' against 'vector'\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os,\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1061:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'basic_string_view' against 'vector'\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os,\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1078:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'shared_ptr' against 'vector'\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/complex:1439:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'complex' against 'vector'\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1043:11: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: requirement '_And<is_base_of<ios_base, basic_ostream<char> &>,\n",
      "      __is_ostreamable<basic_ostream<char> &&, const vector<basic_string<char, char_traits<char>,\n",
      "      allocator<char> >, allocator<basic_string<char, char_traits<char>, allocator<char> > > > &> >::value'\n",
      "      was not satisfied [with _Stream = std::__1::basic_ostream<char> &, _Tp =\n",
      "      std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>\n",
      "      >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>,\n",
      "      std::__1::allocator<char> > > >]\u001b[0m\n",
      "_Stream&& operator<<(_Stream&& __os, const _Tp& __x)\n",
      "\u001b[0;1;32m          ^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1097:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'bitset' against 'vector'\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/valarray:4131:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: substitution failure [with _Expr1 = std::__1::basic_ostream<char>, _Expr2 =\n",
      "      std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>\n",
      "      >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>,\n",
      "      std::__1::allocator<char> > > >]: no type named 'value_type' in 'std::__1::basic_ostream<char>'\u001b[0m\n",
      "operator<<(const _Expr1& __x, const _Expr2& __y)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/valarray:4146:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: substitution failure [with _Expr = std::__1::basic_ostream<char>]: no type\n",
      "      named 'value_type' in 'std::__1::basic_ostream<char>'\u001b[0m\n",
      "operator<<(const _Expr& __x, const typename _Expr::value_type& __y)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/valarray:4162:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: requirement '__is_val_expr<vector<basic_string<char, char_traits<char>,\n",
      "      allocator<char> >, allocator<basic_string<char, char_traits<char>, allocator<char> > > > >::value'\n",
      "      was not satisfied [with _Expr = std::__1::vector<std::__1::basic_string<char,\n",
      "      std::__1::char_traits<char>, std::__1::allocator<char> >,\n",
      "      std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>,\n",
      "      std::__1::allocator<char> > > >]\u001b[0m\n",
      "operator<<(const typename _Expr::value_type& __x, const _Expr& __y)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m\u001b[1m/Users/rbasnet/miniconda3/envs/cpp/include/c++/v1/ostream:1090:1: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate template ignored: could not match 'unique_ptr' against 'vector'\u001b[0m\n",
      "operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p)\n",
      "\u001b[0;1;32m^\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "// can't cout and cin into a vector as awhole\n",
    "cout << words;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[I, love, c++, vectors]\n"
     ]
    }
   ],
   "source": [
    "printVector(words);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 39]\n"
     ]
    }
   ],
   "source": [
    "printVector(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 25, 39 }"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning vector from functions\n",
    "- since vector supports `=` copy operator, returning vector from functions is possible\n",
    "- since returned vector needs to be copied it can be costly\n",
    "    - it's best practice to pass vector as reference to get the data/results out of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "// function that gets vector of integers from standard input\n",
    "void getNumbers(vector<int> & numbers) {\n",
    "    cout << \"Enter as many whole numbers as you wish.\\nEnter 'done' when done:\\n\";\n",
    "    int num;\n",
    "    while(cin >> num) // cin returns false when it fails to parse 'done'\n",
    "        numbers.push_back(num);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "// create an empty vector\n",
    "vector<int> my_numbers;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter as many whole numbers as you wish.\n",
      "Enter 'done' when done:\n",
      "10\n",
      "-11\n",
      "20\n",
      "30\n",
      "40\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "getNumbers(my_numbers);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 10, -11, 20, 30, 40 }"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two-dimensional vector\n",
    "- if we insert vectors as an element to a vector, we essentially get a 2-D vector\n",
    "    - works similar to 2-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's declare a 2-d vector of integers\n",
    "vector< vector<int> > matrix;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "// add the first vector - first row\n",
    "matrix.push_back({1, 2, 3, 4});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 1, 2, 3, 4 }"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's add an empty vector as the second element or 2nd row\n",
    "matrix.push_back(vector<int>());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's add elements to the 2nd vector or 2nd row\n",
    "matrix[1].push_back(5);\n",
    "matrix[1].push_back(6);\n",
    "matrix[1].push_back(7);\n",
    "matrix[1].push_back(8);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 5, 6, 7, 8 }"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// access element of vector elements\n",
    "// first row, first column\n",
    "matrix[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// 2nd row, fourth column\n",
    "matrix[1][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sort vector\n",
    "- vector like array needs to be sorted often to solve many problems\n",
    "- let's use built-in `sort` function in `algorithm` library\n",
    "    - `sort` function implements one of the fastest sorting algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <vector>\n",
    "#include <algorithm> // sort()\n",
    "#include <iterator> // begin() and end()\n",
    "#include <functional> // greater<>();\n",
    "#include <iostream>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector<int> some_values = { 100, 99, 85, 40, 1233, 1};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's sort some_values \n",
    "sort(begin(some_values), end(some_values));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 1, 40, 85, 99, 100, 1233 }"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "sort(some_values.begin(), some_values.end(), greater<int>());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1233, 100, 99, 85, 40, 1]\n"
     ]
    }
   ],
   "source": [
    "printVector(some_values);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 1, 2, 3, 4 }"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "// sort in increasing order\n",
    "sort(matrix[0].begin(), matrix[0].end());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 1, 2, 3, 4 }"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "// sort in non-increasing order\n",
    "sort(matrix[0].begin(), matrix[0].end(), greater<int>());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ 4, 3, 2, 1 }"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labs\n",
    "\n",
    "1. The following lab demonstrates the usage of vector data structure and some operations on vectors.\n",
    "    - use partial solution `numberSystem.cpp` file in [labs/vectors/numSystem](./labs/vectors/numSystem/) folder\n",
    "    - use Makefile to compile and debug the program\n",
    "    - fixe all the FIXMEs and write #FIXED# next to each FIXME once fixed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "### Sove all exercises listed in Array chapter using vector instead.\n",
    "\n",
    "### More exercises\n",
    "1. Write a function that splits a given text/string into a vector of individual words\n",
    "    - each word is sequence of characters separated by a whitespace\n",
    "    - write 3 test cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Solution to Exercise 1\n",
    "void splitString(vector<string> &words, string text) {\n",
    "    string word;\n",
    "    stringstream ss(text);\n",
    "    while (ss >> word) {\n",
    "        words.push_back(word);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "void test_splitString() {\n",
    "    vector<string> answer;\n",
    "    splitString(answer, \"word\");\n",
    "    vector<string> actual = {\"word\"};\n",
    "    assert(answer == actual);\n",
    "    answer.clear();\n",
    "    splitString(answer, \"two word\");\n",
    "    vector<string> actual1 = {\"two\", \"word\"};\n",
    "    assert(answer == actual1);\n",
    "    answer.clear();\n",
    "    splitString(answer, \"A sentence with multiple words!\");\n",
    "    vector<string> actual2 = {\"A\", \"sentence\", \"with\", \"multiple\", \"words!\"};\n",
    "    assert(answer == actual2);\n",
    "    answer.clear();\n",
    "    cerr << \"all test cases is passed for splitString()\\n\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_splitString();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector<string> tokens;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// not needed but just in case!\n",
    "tokens.clear();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splitString(tokens, \"This is a long sentence so long that it's hard to comprehend!\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### complete program can be found in [demos/vectors/splitString/](./demos/vectors/splitString/)\n",
    "\n",
    "2. Airline Reservation System\n",
    "    - Write a C++ menu-driven CLI-based program that let's an airline company manage airline reservation on a single aircraft they own with the following requirements:\n",
    "    - aircraft has 10 rows with 2 seat on each row\n",
    "    - program provieds menu option to display all the avaialable seats\n",
    "    - program provides menu option to let user pick any available seat\n",
    "    - program provides menu option to creates total sales report\n",
    "    - program provides menu option to update price of any seat\n",
    "    \n",
    "3. Triangle\n",
    "    - write a program to compute area and perimeter of a triangle given 3 sides using vector\n",
    "    - prompt user to enter 3 sides of a triangle\n",
    "        - implement input validation and validate the triangle\n",
    "    - use as many function(s) as possible\n",
    "    - write at least 3 test cases for each computing functions\n",
    "    - a sample solution can be found in [demos/vectors/triangle/](./demos/vectors/triangle/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kattis problems\n",
    "- problems that require to store large amount of data in sequential order in memory can use vector very effectively\n",
    "- design your solutions in a way that it can be tested writing automated test cases\n",
    "\n",
    "\n",
    "1. Dice Game - https://open.kattis.com/problems/dicegame\n",
    "2. Falling Apart - https://open.kattis.com/problems/fallingapart\n",
    "3. Height Ordering - https://open.kattis.com/problems/height\n",
    "4. What does the fox say? - https://open.kattis.com/problems/whatdoesthefoxsay\n",
    "5. Army Strength (Easy) - https://open.kattis.com/problems/armystrengtheasy\n",
    "6. Army Strength (Hard) - https://open.kattis.com/problems/armystrengthhard\n",
    "7. Black Friday - https://open.kattis.com/problems/blackfriday\n",
    "8. Bacon, Eggs and Spam - https://open.kattis.com/problems/baconeggsandspam\n",
    "9. Toflur - https://open.kattis.com/problems/toflur\n",
    "\n",
    "### sorting vectors with two keys\n",
    "1. Roll Call - https://open.kattis.com/problems/rollcall\n",
    "2. Cooking Water - https://open.kattis.com/problems/cookingwater"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "- this chapter covered C++ vector container STL\n",
    "- vector is an easier alternative to C-array\n",
    "- vector is and advanced type that you can create/instantiate bojects from\n",
    "- the type of the data must be mentioned as a template parameter while declaring vectors\n",
    "- provides many out-of the box common operations in the form of member functions or methods\n",
    "- vector can be passed to functions; returning a large vector may not be effective due to copying of data\n",
    "- probems and sample solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++14",
   "language": "C++14",
   "name": "xcpp14"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}