6th

1. The parameter is a 2D array

2. int array[10][10];
3. void passFunc(int a[][10])
4. {
5. // ...
6. }
passFunc(array);
7. The parameter is an array containing pointers

8. int *array[10];
9. for(int i = 0; i < 10; i++)
10. array[i] = new int[10];
11. void passFunc(int *a[10]) //Array containing pointers
12. {
13. // ...
14. }
passFunc(array);
15. The parameter is a pointer to a pointer

16. int **array;

17. array = new int *[10];
18. for(int i = 0; i <10; i++)
19. array[i] = new int[10];
20. void passFunc(int **a)
21. {
22. // ...
23. }
passFunc(array);

1) Print anagrams together

void sortv(vector<string> vec){

int i,j;
vector<string> vec2;

for(i=0;i<vec.size();i++){
// sort(vec[i].begin(),vec[i].end());
vec2.push_back(vec[i]);
}
 for(i=0;i<vec.size();i++){
sort(vec[i].begin(),vec[i].end());

for(i=0;i<vec.size();i++){
cout<<vec[i]<<" ";

}
j=0;
int n=vec.size();
int arr[n];
for(i=0;i<n;i++){
arr[i]=0;
}
for(j=0;j<n;j++){
cout<<"j="<<j<<"\n";
for(i=0;i<n;i++){
if(vec[j]==vec[i] && arr[i]==0){
cout<<vec2[i]<<" ";
arr[i]=1;
// vec.erase(vec.begin()+i);
//vec2.erase(vec2.begin()+i);
}

}
}

cout<<"\n";
/* sort(vec.begin(),vec.end());
for(i=0;i<vec.size();i++){
cout<<vec[i]<<" ";

}*/
cout<<"\n";
}

1 // lexicographical_compare example
2 #include <iostream> // std::cout, std::boolalpha
3 #include <algorithm> // std::lexicographical_compare
4 #include <cctype> // std::tolower
5
6 // a case-insensitive comparison function:
7 bool mycomp (char c1, char c2)
8 { return std::tolower(c1)<std::tolower(c2); }
9
10 int main () {
11 char foo[]="Apple";
12 char bar[]="apartment";
13
14 std::cout << std::boolalpha;
15
16 std::cout << "Comparing foo and bar lexicographically (foo<bar):\n";
17
18 std::cout << "Using default comparison (operator<): ";
19 std::cout << std::lexicographical_compare(foo,foo+5,bar,bar+9);
20 std::cout << '\n';
21
22 std::cout << "Using mycomp as comparison object: ";
23 std::cout <<
24 std::lexicographical_compare(foo,foo+5,bar,bar+9,mycomp);
25 std::cout << '\n';
26
27 return 0;
}
2) Dijikstra

// A C / C++ program for Dijkstra's single source shortest path algorithm.

// The program is for adjacency matrix representation of the graph

#include <stdio.h>
#include <limits.h>

// Number of vertices in the graph

#define V 9

// A utility function to find the vertex with minimum distance value, from
// the set of vertices not yet included in shortest path tree
int minDistance(int dist[], bool sptSet[])
{
// Initialize min value
int min = INT_MAX, min_index;

for (int v = 0; v < V; v++)

if (sptSet[v] == false && dist[v] <= min)
min = dist[v], min_index = v;

return min_index;
}

// A utility function to print the constructed distance array

int printSolution(int dist[], int n)
{
printf("Vertex Distance from Source\n");
for (int i = 0; i < V; i++)
printf("%d \t\t %d\n", i, dist[i]);
}

// Funtion that implements Dijkstra's single source shortest path algorithm

// for a graph represented using adjacency matrix representation
void dijkstra(int graph[V][V], int src)
{
int dist[V]; // The output array. dist[i] will hold the shortest
// distance from src to i

bool sptSet[V]; // sptSet[i] will true if vertex i is included in

shortest
 // path tree or shortest distance from src to i is
finalized

// Initialize all distances as INFINITE and stpSet[] as false

for (int i = 0; i < V; i++)
dist[i] = INT_MAX, sptSet[i] = false;

// Distance of source vertex from itself is always 0

dist[src] = 0;

// Find shortest path for all vertices

for (int count = 0; count < V-1; count++)
{
// Pick the minimum distance vertex from the set of vertices not
// yet processed. u is always equal to src in first iteration.
int u = minDistance(dist, sptSet);

// Mark the picked vertex as processed

sptSet[u] = true;

// Update dist value of the adjacent vertices of the picked vertex.

for (int v = 0; v < V; v++)

// Update dist[v] only if is not in sptSet, there is an edge from

// u to v, and total weight of path from src to v through u is
// smaller than current value of dist[v]
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX
&& dist[u]+graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u][v];
}

// print the constructed distance array

printSolution(dist, V);
}

// driver program to test above function

int main()
{
/* Let us create the example graph discussed above */
int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 0, 10, 0, 2, 0, 0},
{0, 0, 0, 14, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};

dijkstra(graph, 0);

return 0;
}
Run on IDE
3)
// C++ program to count all distinct binary strings
// without two consecutive 1's
#include <iostream>
using namespace std;

int countStrings(int n)
{
int a[n], b[n];
a[0] = b[0] = 1;
for (int i = 1; i < n; i++)
{
a[i] = a[i-1] + b[i-1];
b[i] = a[i-1];
}
return a[n-1] + b[n-1];
}
4) Cin string with spaces

getline (cin, mystr);

5)input string of int

int a[3],j,i=0;

string s;

getline(cin,s);

cout<<s;

while(cin>>j){

a[i]=j;

cout<<j;

i++;

6)to cin stream

void copy_string(istream& in, ostream& out)
{
string str;
in >> str;
out << str;
}

stringstream ss;
copy_string(cin, ss);

or

verload operator >>, it solves.[B

istream& operator >> (istream& in, stringstream& ss);

int main (int argc, char* argv[])
{
stringstream ss; cin >> ss; cout << ss.str() << endl; return 0;
}
istream& operator >> (istream& in, stringstream& ss){
string s; in >> s; ss << s; return in;
}

7)