Input: 

The number of node(optional/removable) v , then the number of edges e, then the edges one by one and lastly the starting node.

Objective:

DFS algorithm 
Using recursive method, hence no pushing and popping into any stack.
Input  is taken by adjacency list approach

Approach:

Using c++ stl, vector (each element of the vector is a list of elements). 

Try it here

 #include <bits/stdc++.h>
#define MAX_SIZE 100
using namespace std;


 void dfs(std::vector<int>*, int, bool*); 

void dfs(vector <int> gph[MAX_SIZE], int ss, bool visited[MAX_SIZE])
{
    visited[ss]=true;
    cout<<" "<<ss<<endl;
    //s.push(ss);
    
    for(int j=0;j<gph[ss].size();j++)
    {
        int t=gph[ss][j];
        if((visited[t])==false)
            dfs(gph,gph[ss][j],visited);
        //cout<<" "<<g[s][j]<<endl;
        
    }
    
}

int main()
{
    int v;
    int e;
    
    vector <int> g[MAX_SIZE];
    bool visited[MAX_SIZE];
    
    for(int i=0;i<v;i++)
    {
        visited[i]=false;
    }
    
    
    
    int start;
    
    cin>>v;
    cin>>e;
    int x;
    int y;
    for(int i=0;i<e;i++)
    {
        cin>>x>>y;
        g[x].push_back(y); 
        g[y].push_back(x); //because its undirected here
        
    }
    cin>>start;

    dfs(g, start, visited);


    return 0;
}

 

The Best Player from HackerEarth 
Try here

Approach:

Using c++ stl, pair, sort method

Run and check at  here

#include<bits/stdc++.h>
#define MAX_SIZE 1000
using namespace std;

bool sorting_it(const pair<string,long> &a, const pair<string,long> &b ) {
    
    
    if(a.second!=b.second)
        return (a.second>b.second);
    else
        return(a.first<b.first);
    
}

int main()
{
    long N;
    long T;
    cin>>N>>T;
    string str;
    long q;
    pair<string,long> p[MAX_SIZE];
    for(long i=0;i<N;i++)
    {
        cin>>str>>q;
        p[i]=make_pair(str,q);
    }
    sort(p,p+N,sorting_it);
    for(long i=0;i<T;i++)
    {
       cout<<p[i].first<<endl;
      
    }
    return 0;
}  

Input: 

T number of test-cases, each with n number of strings

Objective:

To find the most repeating string (in dictionary order) for each test case.

Approach:

Using c++ stl, map

Try it here

 #include <bits/stdc++.h>  
 using namespace std;  
 int main()  
 {  
   int t;  
   cin>>t;  
   while(t--){  
        int n; cin>>n;  
        unordered_map<string, int> um;  
        string word;  
        for(int i = 0; i < n; i++){  
          cin>>word;  
          um[word]++;  
        }  
        unordered_map<string, int> :: iterator it;  
        string res; int max = 0;  
        for(auto it : um){  
          if(it.second > max){  
            max = it.second;  
            res = it.first;  
          }  
          else if(it.second == max && it.first < res){  
            max = it.second;  
            res = it.first;  
          }  
        }  
        cout<<res<<endl;  
      }  
      return 0;  
 }  

Input: 

2 arrays (one with x co-ordinates and another with y co-ordinates) to describe the points

Objective:

To arrange in ascending order of the x-ordinates and if same then descending order of their y-ordinates

Approach:

Using c++ stl, vector, pair, sort method

(It was asked in amazon 2019 campus recruitment for 20 marks)

Run and check at  here

 #include<bits/stdc++.h>  
 using namespace std;  
 bool sortBylogic(const pair<int,int> &a,  
 const pair<int,int> &b)  
 {  
 if(a.first!=b.first)  
 return(a.first < b.first);  
 else  
 return(a.second > b.second);  
 }  
 int main()  
 {  
 //{4,3},{2,1},{2,6},{3,0} => 2,6 2,1 3,0 4,3  
 vector< pair <int,int> > pts; //both x and y coordinates of the point will be stored here as pairs  
 int inX[]={4,2,2,3};  
 int inY[]={3,1,6,0};  
 for(int i=0;i<4;i++)  
 {  
 pts.push_back(make_pair(inX[i],inY[i]));  
 }  
 sort(pts.begin(),pts.end(),sortBylogic);  
 for (int i=0; i<4; i++)  
 {  
 cout << pts[i].first << " "<< pts[i].second << endl;  
 }  
 }