Rank Scores

Write a SQL query to rank scores. If there is a tie between two scores, both should have the same ranking. Note that after a tie, the next ranking number should be the next consecutive integer value. In other words, there should be no "holes" between ranks.

Example

Table: Score

 Id   Score 
 1    3.40  
 2    3.55  
 3    5.00  
 4    3.75  
 5    4.00  
 6    3.55  

Output:

 Output :
 score  Rank    
 5.00   1 
 4.00   2       
 3.75   3
 3.55   4       
 3.55   4       
 3.40   5

Approach

Mysql

SELECT 
    Score as Score,
    DENSE_RANK() OVER(ORDER BY Score DESC) as 'Rank'
FROM 
    Scores;

Oracle 

SELECT 
    Score as Score,
    DENSE_RANK() OVER(ORDER BY Score DESC) as Rank
FROM 
    Scores;

Check whether two strings are anagram of each other

Write a program to check whether two strings are an anagram of each other.

Anagram Strings: Two strings are said to be anagram if the characters' frequency is the same in both the strings.

Example 1:

Input: str1="abc" , str2="cab"
Output: Strings are anagram

Example 2:

Input: str1="aacc" , str2="ccac"
Output: String are not anagram

Approach

Java

import java.util.HashMap;

public class StringAnagram {
    public static void main(String[] args) {
        String str1 = "aacc";
        String str2 = "ccac";
        if (checkStrAnagram(str1, str2)) {
            System.out.println("Strings are anagram");
        } else {
            System.out.println("Strings are not anagram");
        }
    }

    // Method used for check string anagarm
    private static boolean checkStrAnagram(String str1, String str2) {
        // hold char frequency
        HashMap<Character, Integer> map = new HashMap<>();
        // Base case // null check
        if (str1.length() == 0 && str2.length() == 0)
            return true;
        if (str1 == null || str1.length() == 0 || 
                    str2 == null || str2.length() == 0) {
            return false;
        }
        // calculate frequency of str1
        for (int i = 0; i < str1.length(); i++) {
            map.put(str1.charAt(i), 
                map.getOrDefault(str1.charAt(i), 0) + 1);
        }
        // check frequency of str1 is equals of str2
        for (int i = 0; i < str2.length(); i++) {
            // if element not contain in str1
            if (!map.containsKey(str2.charAt(i)))
                return false;
            // if frequency not equal
            if (map.get(str2.charAt(i)) == -1)
                return false;
            map.put(str2.charAt(i), 
                map.getOrDefault(str2.charAt(i), 0) - 1);
        }
        // worst case : check remaining frequency
        for (Character ch : map.keySet()) {
            if (map.get(ch) > 0) {
                return false;
            }
        }

        return true;
    }
}

C++

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

//function to check the 
//given strings are anagram or not
bool checkAnagram(string str1,string str2)
{
    int len1=str1.size();
    int len2=str2.size();
    if(len1!=len2)
      return false;
    unordered_map<char,int> ump;
    for(int i=0;i<len1;i++)
      {
          ump[str1[i]]++;
      }
     for(int i=0;i<len2;i++)
       {
           if(ump[str2[i]]==0)
              return false;
           else
           ump[str2[i]]--;
           
       }
    for(auto it=ump.begin();it!=ump.end();it++)
      {
          if(it->second>0)
            return false;
      }
    return true;
}
int main()
{
    string str1="aacc";
    string str2="ccac";
    if(checkAnagram(str1,str2))
      cout<<"Srings are anagram\n";
    else
     cout<<"String are not anagram\n";
    return 0;
}

Fahrenheit to Celsius

Write a program to convert Fahrenheit to Celcius.

Example

Input: Fehrenheit= 37.76
Output: 3.2

Approach

Java

public class FahrenheitToCelsius {
    public static void main(String[] args) {
        double fahrenheit = 37.76;
        double celsius = fahToCel(fahrenheit);
        System.out.printf("Celsius is %.2f", celsius);
    }

    private static double fahToCel(double fahrenheit) {
        // Formula : ((f + 40) ÷ 1.8) − 40 = c.
        double celsius = ((fahrenheit + 40) / 1.8) - 40;
        return celsius;
    }

}

C++

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

//function to convert the
//fahrenheit to celcius
double fahrenheitToCelcius(double fahrenheit)
{
    //formula: ((f+40)/1.8)-40=c
    double celcius=((fahrenheit+40)/1.8)-40;
    return celcius;
}
int main()
{
    double fahrenheit=37.76;
    double celcius=fahrenheitToCelcius(fahrenheit);
    cout<<"Celcius is ";
    cout<<celcius<<"\n";
    return 0;
}

Celsius to fahrenheit

Write a program to convert Celcius to Fahrenheit.

Example

Input: celsius= 3.2
Output: 37.76

Approach

Java

public class CelsiusToFahrenheit {
    public static void main(String[] args) {
        double celsius = 3.2;
        double fahrenheit = celToFah(celsius);
        System.out.printf("Fahrenheit is %.2f", fahrenheit);
    }

    private static double celToFah(double celsius) {
        // Formula ((c + 40) × 1.8) − 40 = f.
        double fahrenheit = ((celsius + 40) * 1.8) - 40;
        return fahrenheit;
    }

}

C++

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

//function to convert celcius
//to fahrenheit
double celciusToFahrenheit(double celcius)
{
    //formula : ((c+40)*1.8)-40=f
    double fahrenenheit=((celcius+40)*1.8)-40;
    return fahrenenheit;
}
int main()
{
    double celcius=3.2;
    double faherenheit=celciusToFahrenheit(celcius);
    cout<<"Faherenheit is ";
    cout<<faherenheit<<"\n";
    return 0; 
}

Find Single Number from array

Write a program to Find a Single Number from an array.

 Example 1:

Input: nums = { 2, 2, 1, 3, 1 }
Output: 3

Approach 1: Using Hashmap (Java), map (C++) 

Java

import java.util.HashMap;

public class FindSingleNumber {
    public static void main(String[] args) {
        int[] nums = { 2, 2, 1, 3, 1 };
        int single = singleNumber(nums);
        System.out.println("Single number is " + single);
    }

    // method for find single number
    public static int singleNumber(int[] nums) {
        // create map for hold frequency of number
        HashMap<Integer, Integer> map = new HashMap<>();
        // Iterate till end of array
        for (int i = 0; i < nums.length; i++) {
            // add in map based on condition
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        // find single number from map
        for (int key : map.keySet()) {
            // if single number the return
            if (map.get(key) == 1) {
                return key;
            }
        }
        return 0;
    }
}

C++

#include <bits/stdc++.h>
using namespace std;
//function to find the single element
//in the array ,array contains all element twice
//except the one element
int singleElement(int arr[],int n)
{
    //map to hold the count of 
    //all the number
    map<int,int> mp;
    for(int i=0;i<n;i++)
      {
        //increment the count of
        //current element
          mp[arr[i]]++;
      }
    
    //initialize the single element as arr[0]
    int single=arr[0];
   
   //iterate the map
    for(auto it=mp.begin();it!=mp.end();it++)
       {
           //if frequency is 1
           if(it->second==1)
             {
                 //store the single as the current 
                 //element
                 single=it->first;
                 break;
             }
       }
    //return the single element
    return single;
}
int main()
{
    int arr[]={2,2,1,3,1};

    //find the length of array
    int n=sizeof(arr)/sizeof(arr[0]);
    int single=singleElement(arr,n);
    cout<<"Single element is ";
    cout<<single<<"\n";
    return 0;
}

Approach 2: Using XOR (because xor of two same number becomes 0)

Java

public class FindSingleNumber {
    public static void main(String[] args) {
        int[] nums = { 2, 2, 1, 3, 1 };
        int single = singleNumber(nums);
        System.out.println("Single number is " + single);
    }

    // method for find single number
    public static int singleNumber(int[] nums) {
        int singleElement = nums[0];
        // Iterate till end of array
        for (int i = 1; i < nums.length; i++) {
            // XOR manipulation
            singleElement = singleElement ^ nums[i];
        }

        return singleElement;
    }
}

C++

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

//function to find the single
//element of the array
//array contains all elements twice
//execpt the one element which occur 
//one time
int singleElement(int arr[],int n)
{
    int single=arr[0];

    //iterate for all the 
    //element of the array
    for(int i=1;i<n;i++)
      {
          //update single element as 
          //single =single^arr[i]
          //xor of 2 same number beomes 0
          single=single^arr[i];
      }

    //return the single element
    return single;
}
int main()
{
    int arr[]={2,2,1,3,1};

    //find the length of array
    int n=sizeof(arr)/sizeof(arr[0]);
    int single=singleElement(arr,n);
    cout<<"Single element is ";
    cout<<single<<"\n";
    return 0;
}

Can Place Flowers

You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.

Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule.

Example 1:

Input: flowerbed = [1,0,0,0,1,0,0,0,1], n = 2
Output: Given all flowers can be place

Example 2:

Input: flowerbed =[1,0,0,0,1,0,0,0,1], n = 3
Output: Given all flowers can not be place

Approach

Java

public class CanPlaceFlowers {
    public static void main(String[] args) {
        int flowerbed[] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
        int n = 3;
        if (canPlaceFlowers(flowerbed, n)) {
            System.out.println("Given all flowers can be place");
        } else {
            System.out.println("Given all flowers can not be place");
        }

    }

    public static boolean canPlaceFlowers(int[] flowerbed, int n) {
        int prev = 0;

        for (int i = 0; i < flowerbed.length; i++) {
            if (n > 0) {
                int next = 0;
                if (i < flowerbed.length - 1) {
                    next = flowerbed[i + 1];
                }
                if (prev == 0 && flowerbed[i] == 0 && next == 0) {
                    n--;
                    prev++;
                    flowerbed[i] = 1;
                }
                prev = flowerbed[i];
            }
        }

        if (n == 0)
            return true;
        else
            return false;
    }
}

C++

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

//function to check that we
//can place the flowers such that no
//two flowers are adjacent 
bool canPlaceFlowers(int flowerbed[], int n,int m)
{
  //count the no of current placed flower
   int cnt=0;
   int flag=0;

   //if their is no flower to put
   //return true
   if(n==0)
      return true;
 
 //if only one element and only 
 //one flower to put then return true
 //if flowerbed[0]=0
  if(m==1&&n==1&&flowerbed[0]==0)
      return true;

//iterate for all the index
  for(int i=0;i<m;i++)
     {

      //if we are at first position
        if(i==0)
          {
              //if first is empty and second also empty
              //the increment cnt and make flowerbed[i]=1
           if(flowerbed[i]==0&&i+1<m&&flowerbed[i+1]==0)
             {
                cnt++;
                flowerbed[i]=1;
             }
           }

         //if we are at the last position of the array
         //if second last is empty and last is empty 
         //increment the count ans make the last as 1
         else if(i==m-1)
         {
             if(i-1>=0&&flowerbed[i-1]==0&&flowerbed[i]==0)
               {
                 cnt++;
                 flowerbed[i]=1;
              }
         }
    //else we check left of position and right of position
     else
         {
        //if left ,right and current index is 0 then
        //increment the count and make the current index as 1
         if(flowerbed[i]==0&&flowerbed[i-1]==0&&flowerbed[i+1]==0)
          {
              cnt++;
              flowerbed[i]=1;
           }
          }
      
      //if count becomes n break out of loop
      //and  make flag as 1
      if(cnt==n)
            {
                flag=1;
                break;
            }
      }
    
    //if flag remain 0 then return false
    if(flag==0) 
        return false;
    //else return true
    else
       return true;
}
int main()
{
  int flowerbed[]={1,0,0,0,1,0,0,0,1};
  int n=3;
  int m=sizeof(flowerbed)/sizeof(flowerbed[0]);
  if(canPlaceFlowers(flowerbed,n,m))
    cout<<"Given all flower can be place\n";
  else
    cout<<"Given all flowers can not be place\n";
  return 0;
  
}