Added common interview programs from hackerrank and codechef

Author: shreayan98c

Arrays/CoinFlip.py

@@ -0,0 +1,69 @@
+# Coin Flip
+
+# Little Elephant was fond of inventing new games. After a lot of research, Little Elephant came to know that most of the animals in the forest were showing less interest to play the multi-player games.Little Elephant had started to invent single player games, and succeeded in inventing the new single player game named COIN FLIP.
+
+# In this game the player will use N coins numbered from 1 to N, and all the coins will be facing in "Same direction" (Either Head or Tail),which will be decided by the player before starting of the game.
+
+# The player needs to play N rounds.In the k-th round the player will flip the face of the all coins whose number is less than or equal to k. That is, the face of coin i will be reversed, from Head to Tail, or, from Tail to Head, for i ≤ k.
+
+# Elephant needs to guess the total number of coins showing a particular face after playing N rounds. Elephant really becomes quite fond of this game COIN FLIP, so Elephant plays G times. Please help the Elephant to find out the answer.
+
+# Input
+# The first line of input contains an integer T, denoting the number of test cases. Then T test cases follow.
+
+# The first line of each test contains an integer G, denoting the number of games played by Elephant. Each of the following G lines denotes a single game, and contains 3 space separeted integers I, N, Q, where I denotes the initial state of the coins, N denotes the number of coins and rounds, and Q, which is either 1, or 2 as explained below.
+
+# Here I=1 means all coins are showing Head in the start of the game, and I=2 means all coins are showing Tail in the start of the game. Q=1 means Elephant needs to guess the total number of coins showing Head in the end of the game, and Q=2 means Elephant needs to guess the total number of coins showing Tail in the end of the game.
+
+# Output
+# For each game, output one integer denoting the total number of coins showing the particular face in the end of the game.
+
+# Constraints
+# 1 ≤ T ≤ 10
+# 1 ≤ G ≤ 20000
+# 1 ≤ N ≤ 109
+# 1 ≤ I ≤ 2
+# 1 ≤ Q ≤ 2
+# Example
+
+# Input:
+# 1
+# 2
+# 1 5 1
+# 1 5 2
+
+# Output:
+# 2
+# 3
+# Explanation:
+# In the 1st game in Example: I=1, so initial arrangement of coins are H H H H H, and now Elephant will play 5 rounds and coin faces will be changed as follows
+# After the 1st Round: T H H H H
+# After the 2nd Round: H T H H H
+# After the 3rd Round: T H T H H
+# After the 4th Round: H T H T H
+# After the 5th Round: T H T H T
+
+# Finally Q=1, so we need to find the total number of coins showing Head, which is 2.
+
+# In the 2nd game in Example: This is similar to the 1st game, except Elephant needs to find the total number of coins showing Tail. So the Answer is 3. (Please see the final state of the coins in the 1st game)
+
+# cook your code here
+t = input()
+t1 = 0
+while t1 < t:
+    g = input()
+    g1 = 0
+    while g1 < g:
+        arr = input().split(' ')
+        i = int(arr[0])
+        n = int(arr[1])
+        q = int(arr[2])
+        if n%2 == 0:
+            print(n/2)
+        else:
+            if i == q:
+                print(n/2)
+            else:
+                print((n/2)+1)
+        g1 += 1
+    t1 += 1

Miscellaneous/TrailingZerosOfFactorial.py

@@ -0,0 +1,46 @@
+# Trailing Zeros of Factorial
+
+# The most important part of a GSM network is so called Base Transceiver Station (BTS). These transceivers form the areas called cells (this term gave the name to the cellular phone) and every phone connects to the BTS with the strongest signal (in a little simplified view). Of course, BTSes need some attention and technicians need to check their function periodically.
+
+# The technicians faced a very interesting problem recently. Given a set of BTSes to visit, they needed to find the shortest path to visit all of the given points and return back to the central company building. Programmers have spent several months studying this problem but with no results. They were unable to find the solution fast enough. After a long time, one of the programmers found this problem in a conference article. Unfortunately, he found that the problem is so called "Traveling Salesman Problem" and it is very hard to solve. If we have N BTSes to be visited, we can visit them in any order, giving us N! possibilities to examine. The function expressing that number is called factorial and can be computed as a product
+
+# 1.2.3.4....N. The number is very high even for a relatively small N.
+
+# The programmers understood they had no chance to solve the problem. But because they have already received the research grant from the government, they needed to continue with their studies and produce at least some results. So they started to study behavior of the factorial function.
+
+# For example, they defined the function Z. For any positive integer N, Z(N) is the number of zeros at the end of the decimal form of number N!. They noticed that this function never decreases. If we have two numbers N1<N2, then Z(N1) <= Z(N2). It is because we can never "lose" any trailing zero by multiplying by any positive number. We can only get new and new zeros. The function Z is very interesting, so we need a computer program that can determine its value efficiently.
+
+# Input
+# There is a single positive integer T on the first line of input (equal to about 100000). It stands for the number of numbers to follow. Then there are T lines, each containing exactly one positive integer number N, 1 <= N <= 1000000000.
+
+# Output
+# For every number N, output a single line containing the single non-negative integer Z(N).
+
+# Example
+# Sample Input:
+
+# 6
+# 3
+# 60
+# 100
+# 1024
+# 23456
+# 8735373
+# Sample Output:
+
+# 0
+# 14
+# 24
+# 253
+# 5861
+# 2183837
+
+t = int(input())
+for i in range(t):
+    num = int(input())
+    count=0
+    j=5
+    while(num//j!=0):
+        count += int(num/j)
+        j*=5
+    print(count)

Queue/DownToZero.cpp

@@ -0,0 +1,56 @@
+// Down to Zero
+
+// You are given Q queries. Each query consists of a single number N. You can perform any of the 2 operations on N in each move:
+
+// 1: If we take 2 integers a and b where N = a x b (a!=1, b!=1), then we can change N = max(a,b)
+
+// 2: Decrease the value of N by 1.
+
+// Determine the minimum number of moves required to reduce the value of N to 0.
+
+// Sample Input
+// 2
+// 3
+// 4
+
+// Sample Output
+// 3
+// 3
+
+// For test case 1, We only have one option that gives the minimum number of moves.
+// Follow 3 -> 2 -> 1 -> 0. Hence, 3 moves.
+
+// For the case 2, we can either go 4 -> 3 -> 2 -> 1 -> 0 or 4 -> 2 -> 1 -> 0. The 2nd option is more optimal. Hence, 3 moves.
+
+int main() 
+{
+    int max=1000001;
+    int i, j, nums[max];
+    
+    //Initializing the array
+    for(i=0;i<max;i++) 
+        nums[i] = -1;
+    nums[0] = 0;
+    nums[1] = 1;
+    nums[2] = 2;
+    nums[3] = 3;
+    
+    for(i=0;i<max;i++)
+    {
+        if(nums[i]==-1 || nums[i]>(nums[i-1]+1))
+            nums[i]=nums[i-1]+1;
+        for(j=1; j<=i && j*i<max; j++)
+            if(nums[j*i]==-1 || (nums[i]+1)<nums[j*i])
+                nums[j*i]=nums[i]+1;
+    }
+    
+    int q;
+    cin>>q;
+    for(i=0; i<q; i++)
+    {
+        int n;
+        cin>>n;
+        cout<<nums[n]<< endl;
+    }
+    return 0;
+}

Strings/Lapindrome.py

@@ -0,0 +1,50 @@
+# Lapindromes 
+
+# Lapindrome is defined as a string which when split in the middle, gives two halves having the same characters and same frequency of each character. If there are odd number of characters in the string, we ignore the middle character and check for lapindrome. For example gaga is a lapindrome, since the two halves ga and ga have the same characters with same frequency. Also, abccab, rotor and xyzxy are a few examples of lapindromes. Note that abbaab is NOT a lapindrome. The two halves contain the same characters but their frequencies do not match.
+# Your task is simple. Given a string, you need to tell if it is a lapindrome.
+
+# Input:
+# First line of input contains a single integer T, the number of test cases.
+# Each test is a single line containing a string S composed of only lowercase English alphabet.
+# Output:
+# For each test case, output on a separate line: "YES" if the string is a lapindrome and "NO" if it is not.
+# Constraints:
+# 1 ≤ T ≤ 100
+# 2 ≤ |S| ≤ 1000, where |S| denotes the length of S
+# Example:
+# Input:
+# 6
+# gaga
+# abcde
+# rotor
+# xyzxy
+# abbaab
+# ababc
+
+
+# Output:
+# YES
+# NO
+# YES
+# YES
+# NO
+# NO
+
+t = int(input())
+for i in range(t):
+    word = input()
+    word_len = len(word)
+    mid = word_len//2
+    if((word_len %2) ==0 ):
+        str1 = word[0:mid]
+        str2 = word[mid:]   
+    else:
+        str1 = word[0:mid]
+        str2 = word[mid+1:]
+    
+    str1 = sorted(str1)
+    str2 = sorted(str2)
+    if(str1 == str2):
+        print("YES")
+    else:
+        print("NO")

Trees/HuffmanDecoding.cpp

@@ -0,0 +1,99 @@
+// Huffman Decoding
+
+// Huffman coding assigns variable length codewords to fixed length input characters based on their frequencies. 
+// More frequent characters are assigned shorter codewords and less frequent characters are assigned longer codewords. 
+// All edges along the path to a character contain a code digit. If they are on the left side of the tree, they will be a 0 (zero). 
+// If on the right, they'll be a 1 (one). Only the leaves will contain a letter and its frequency count. 
+// All other nodes will contain a null instead of a character, and the count of the frequency of all of it and its descendant characters.
+
+// Input characters are only present in the leaves. Internal nodes have a character value of ϕ (NULL). We can determine that our values for characters are:
+
+// A - 0
+// B - 111
+// C - 1100
+// D - 1101
+// R - 10
+// Our Huffman encoded string is:
+
+// A  B  R  A C    A D    A B   R  A
+// 0 111 10 0 1100 0 1101 0 111 10 0
+// or
+// 01111001100011010111100
+
+// To avoid ambiguity, Huffman encoding is a prefix free encoding technique. No codeword appears as a prefix of any other codeword.
+
+// To decode the encoded string, follow the zeros and ones to a leaf and return the character there.
+
+// You are given pointer to the root of the Huffman tree and a binary coded string to decode. You need to print the decoded string.
+
+// Sample Input
+// s="1001011"
+
+// Sample Output
+// ABACA
+
+// Explanation
+
+// S="1001011"
+// Processing the string from left to right.
+// S[0]='1' : we move to the right child of the root. We encounter a leaf node with value 'A'. We add 'A' to the decoded string.
+// We move back to the root.
+
+// S[1]='0' : we move to the left child. 
+// S[2]='0' : we move to the left child. We encounter a leaf node with value 'B'. We add 'B' to the decoded string.
+// We move back to the root.
+
+// S[3] = '1' : we move to the right child of the root. We encounter a leaf node with value 'A'. We add 'A' to the decoded string.
+// We move back to the root.
+
+// S[4]='0' : we move to the left child. 
+// S[5]='1' : we move to the right child. We encounter a leaf node with value C'. We add 'C' to the decoded string.
+// We move back to the root.
+
+//  S[6] = '1' : we move to the right child of the root. We encounter a leaf node with value 'A'. We add 'A' to the decoded string.
+// We move back to the root.
+
+// Decoded String = "ABACA"
+
+// The structure of the node is
+
+typedef struct node 
+{
+  int freq;
+  char data;
+  node * left;
+  node * right;
+
+}
+node;
+
+void decode_huff(node * root, string s) 
+{
+  node * treeroot = root;
+  // char *result = (char*)malloc(sizeof(char)*len);
+  int i = 0, k = 0;
+  while (s[i]!='\0') 
+  {
+    //   printf("s[%d]%c\n", i, s[i]);
+    if (s[i]=='1') 
+    {
+      root = root -> right;
+      if (root->data!='\0') 
+      {
+        printf("%c", root->data);
+        root = treeroot;
+      }
+      i++;
+    } 
+    else 
+    {
+      root = root -> left;
+      if (root->data!='\0') 
+      {
+        printf("%c", root->data);
+        root = treeroot;
+      }
+      i++;
+    }
+  }
+}