Trial to First Pull [IGNORE THIS]

.travis.yml

@@ -35,4 +35,4 @@ matrix:
 
 notifications:
   on_success: change
-  on_failure: change  # `always` will be the setting once code changes slow down
+  on_failure: change  # `always` will be the setting once code changes fast 

ASSIGNMENTS/12 hr to 24 hr format

@@ -0,0 +1,26 @@
+Given a time in 12-hour AM/PM format, convert it to military (24-hour) time.
+
+Note: Midnight is 12:00:00AM on a 12-hour clock, and 00:00:00 on a 24-hour clock. Noon is 12:00:00PM on a 12-hour clock, and 12:00:00 on a 24-hour clock.
+
+Function Description
+
+Complete the timeConversion function in the editor below. It should return a new string representing the input time in 24 hour format.
+
+timeConversion has the following parameter(s):
+
+s: a string representing time in  12-hour format
+Input Format
+
+A single string  containing a time in -hour clock format (i.e. hh:mm:ss AM or hh:mm:ss PM ), where 01<=hh<=12 and 00<=mm,ss<=59 .
+
+Constraints
+
+All input times are valid
+Output Format
+
+Convert and print the given time in 24-hour format, where 00<=hh<=24 .
+
+Sample Input 0:
+07:05:45PM
+Sample Output 0:
+19:05:45

ASSIGNMENTS/3rd Largest number in Unsorted Array.md

@@ -0,0 +1,3 @@
+Use any language & write a program that takes an unsorted array in input & returns the third largest number form Array as output.
+
+Make sure, Solution has minimum complexity possible.

ASSIGNMENTS/A Game of Robots.md

@@ -0,0 +1,39 @@
+You've built some robots and placed them on an one dimensional grid with n cells. Their arrangement is given by a string s of length n. Each character of the string is either '.' or a digit in the range '0' to '9'. A '.' represents that there is no robot at that cell initially. A digit represents a robot initially in that cell. Specifically, the digit x denotes that the range of the robot is from x cells to the left of its starting point to x cells to the right of its starting point.
+
+For example, suppose the 7th character of the string is 3, then that means that there is a robot starting from the 7th cell, and its range is from the 4th cell (7 - 3 = 4) to the 10th cell (7 + 3 = 10) (both end points inclusive). The robots can move only within their range, and even if their range allows it, they cannot move out of the grid.
+
+You want to play a game with these robots. Before starting the game, you can give each robot a starting direction (either left or right). When the robot is initialized with a direction, it will move in that direction until it can (ie. it can't go past its range, and neither can it go outside the grid) and will reverse its direction and go as far as possible in that direction, and then reverse, and so. It will keep going like this forever. Assume that the change of direction happens instantaneously.
+
+But the catch is that each of the robots can start their journey at any time. They don't all have to start at the same second. It won't stop once it starts moving though. And they all move at the same speed of one cell per second, once they start.
+
+The robots have gained consciousness, and have begun questioning their purpose in life. So given a chance, they will collide with each other and end their misery. They can coordinate with each other as well and decide when they should start their journeys. Two robots are said to have collided if they are at the same cell at the same moment.
+
+You are wondering whether it is possible to give the robots the initial directions in such a way that no robots collide with each other (ie. they'll all be safe), or if no matter what initial directions you give, some of them will end up colliding with each other (ie. unsafe).
+<br><br>
+<b>Input</b>
+The first line of the input contains an integer T denoting the number of test cases. The description of the test cases follows.
+The only line of each test case contains a string s.<br>
+<b>Output</b>
+For each test case, output a single line containing "safe" or "unsafe" (without quotes).<br>
+<b>Constraints</b><br>
+1=T=3*104<br>
+1= length of s=50<br>
+s[i] will be one of the following characters {'.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}<br>
+  <b>Example</b>
+<b>Input</b>
+4
+....
+.2.....
+.2...2..
+1.1.1.<br>
+<b>Output</b>
+safe
+safe
+unsafe
+unsafe<br>
+<b>Explanation</b>
+Example 1: No robots. Everything is safe.
+
+Example 2: Only one robot. Everything safe. To give an example of its movement, suppose you give it the starting direction as left and suppose it decides to start moving at time = 5 seconds. Then till t = 5, it is at cell 2 (its starting position, 1-based indexing). At t = 6, it is at cell 1. At t = 7, it is at cell 2, at t = 8, it will be at cell 3, at t = 9 it will be at cell 4 and at t = 10 it will be at cell 3. And so on.
+
+Example 3: No matter what initial directions you give, the two robots can coordinate and start their journeys such that they collide at the cell 4.

ASSIGNMENTS/ACIIIproduct.txt

@@ -8,4 +8,12 @@ Output : 6059
 73 * 83 = 6059
 
 Input : str = "GfG"
-Output : 514182
+Output : 514182
+
+
+Input : str = "ab"
+Output : 9506
+
+Input: str="AB"
+Output: 4290 
+

ASSIGNMENTS/ATM problem.md

@@ -34,3 +34,5 @@ Explanation
 Example case 1: The ATM machine initially contains 10 units of money. The first person comes and withdraws 3 units, so the amount remaining in the machine is 7. Then the second person withdraws 5 units and the remaining amount is 2. The third person wants to withdraw 3 units, but since there are only 2 units of money in the machine, it throws an error and the third person must leave without getting anything. Then the fourth person withdraws 2 units, which leaves nothing in the machine, so the last person does not get anything.
 
 Example case 2: The ATM machine initially contains 6 units of money, so it cannot give anything to the first and second person. When the third person comes, it gives them all the money it has, so the last person does not get anything either.
+
+The operating system and compatibility of that server matters the working of an ATM machine.

ASSIGNMENTS/Advanced prob_FizzBuzz

@@ -0,0 +1,45 @@
+Q)FizzBuzz
+---------------------------------------------------------------------------------
+
+Write a program that prints the numbers in the given range. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”. Print a new line after each string or number.
+Input Format First line will be the number of testcases, T. Next line will have T integers, denoted by N.
+Output Format For each testcase, print the number from 1 to N. But follow the rules given in the problem statement.
+Constraints
+1 <= T <= 10
+N is an integer.
+Please read the below instructions carefully
+You can choose any language from the given list to write your solution.
+All input to the programming solution is to STDIN and output is to STDOUT.
+You don't have to manually give the input to your program, just take the input from STDIN and the code evaluation engine will provide the input to your program.
+For example if you are coding in C, and the first input is an integer then simply do scanf('%d', &i) assuming you are reading that integer to a variable named i. Similarly if you are using C++ simply do cin >> i
+There are two different type of test cases. First type is the sample input and output for which you know both the input and output. You can look at them under the problem statement.
+When you click Compile and Test the code will be compiled and tested only on the sample input that is shown to you. Compile and Test is for you to understand if you solution is compiling and running against the sample input. 5 When you click submit, your code will be judged on multiple test cases which are hidden. These tests are not available for you to see them so you will not know the input on which your code will be tested. But it is assured that all inputs will be in the given constraint limit and in the given format as stated in the problem statement.
+In order for your code to get accepted, it must clear all the judge test cases. In cases where partial marking is allowed, you will awarded partial marks for the number of test cases your solution passes.
+Please note that getting green mark when you hit 'Compile and Test' does not indicate anything on the correctness of your program. It just indicates that your code correctly compiled and ran successfully against the sample input. It can still fail for other test inputs that visible to you.
+Do not output anything, except what it is asked for in the output section. Note that you have to output only in the way that is mentioned. Any extra strings in the output will be treated as wrong answer. Even an extra space can lead to the answer not being accepted.
+Don't assume any constraints on the input based on the sample input that you see, the actual test cases will be much larger in size. But they will always be within the constraints mentioned in the problem.
+To understand how the code is evaluated visit the judge page. There is also a sample code in each language there.
+To further understand how the judge works, look at one of the actual test input file and the corresponding expected output for this problem
+
+
+Sample Input                Sample Output   
+
+2
+3 15               1
+                   2
+                   Fizz
+                   1
+                   2
+                   Fizz
+                   4
+                   Buzz
+                   Fizz
+                   7
+                   8
+                   Fizz
+                   Buzz
+                   11
+                   Fizz
+                   13
+                   14
+                   FizzBuzz

ASSIGNMENTS/ArmstrongNumber.txt

@@ -0,0 +1,22 @@
+**Find given number is an armstrong number or not?
+Armstrong Number
+Input Number: 153
+              1=>1*1*1=1 
+              5=>5*5*5=125
+              3=> 3*3*3=27
+         Sum=>1+125+27=153
+  i.e; 153 is an armstrong number
+
+ Output:
+153 is an armstrong number.
+
+Input Number:125
+              1=>1*1*1=1 
+               2=> 2*2*2=8
+              5=>5*5*5=125
+         Sum=>1+8+125!=125
+  i.e; 153 is not  an armstrong number
+
+ Output:
+125 is not an armstrong number.
+

ASSIGNMENTS/Beginners Problem 2.0

@@ -0,0 +1,14 @@
+# Beginners Problem 2.0
+Our juniors has just entered in coding community. Their first task is to find the frequency of Best numbers present in given list of elements. Best numbers are numbers which are divisible by 2.
+
+SAMPLE INPUT 
+2
+5
+1 2 3 4 5
+3
+1 3 5
+SAMPLE OUTPUT 
+2
+0
+Explanation
+Number of test cases=2 1st test case, number of elements =5 Best numbers are 2 , 4 ; frequency=2 2nd test case, number of elements =3 No Best numbers

ASSIGNMENTS/Bishu and his Girlfriend.md

@@ -0,0 +1,28 @@
+Bishu and his Girlfriend
+
+There are N countries {1,2,3,4....N} and N-1 roads(i.e depicting a tree)
+
+Bishu lives in the Country 1 so this can be considered as the root of the tree.
+
+Now there are Q girls who lives in various countries (not equal to 1) .
+
+All of them want to propose Bishu.But Bishu has some condition.
+
+He will accept the proposal of the girl who lives at minimum distance from his country.
+
+Now the distance between two countries is the number of roads between them.
+
+If two or more girls are at the same minimum distance then he will accept the proposal of the girl who lives in a country with minimum id.
+
+No two girls are at same country.
+
+Input: First line consists of N,i.e number of countries Next N-1 lines follow the type u v which denotes there is a road between u and v. Next line consists of Q Next Q lines consists of x where the girls live.
+
+Output: Print the id of the country of the girl who will be accepted.
+
+Help Him!!!!!
+
+contraints: 2<=N<=1000 1<=u,v<=N 1<=Q<=(N-1)
+
+--------------------------------------------------------
+Author: https://www.hackerearth.com/@satishgpta007

ASSIGNMENTS/CompareLists

@@ -1 +1,10 @@
 Write a Python program to compare two unordered lists (not sets). 
+
+The program are:
+
+from collections import Counter
+def compare_lists(x, y):
+    return Counter(x) == Counter(y)
+n1 = [20, 10, 30, 10, 20, 30]
+n2 = [30, 20, 10, 30, 20, 50]
+print(compare_lists(n1, n2))

ASSIGNMENTS/Directions Reduction.md

@@ -0,0 +1,73 @@
+# Directions Reduction
+
+## **Once upon a time, on a way through the old wild west,…**
+… a man was given directions to go from one point to another. The directions were "NORTH", "SOUTH", "WEST", "EAST". Clearly "NORTH" and "SOUTH" are opposite, "WEST" and "EAST" too. Going to one direction and coming back the opposite direction is a needless effort. Since this is the wild west, with dreadfull weather and not much water, it's important to save yourself some energy, otherwise you might die of thirst!
+
+## How I crossed the desert the smart way.
+
+The directions given to the man are, for example, the following:
+
+```
+["NORTH", "SOUTH", "SOUTH", "EAST", "WEST", "NORTH", "WEST"].
+```
+
+or
+
+```
+{ "NORTH", "SOUTH", "SOUTH", "EAST", "WEST", "NORTH", "WEST" };
+```
+
+or (haskell)
+
+```
+[North, South, South, East, West, North, West]
+```
+
+You can immediatly see that going "NORTH" and then "SOUTH" is not reasonable, better stay to the same place! So the task is to give to the man a simplified version of the plan. A better plan in this case is simply:
+
+```
+["WEST"]
+```
+
+or
+
+```
+{ "WEST" }
+```
+
+or (haskell)
+
+```
+[West]
+```
+
+or (rust)
+
+```
+[WEST];
+```
+
+## Other examples:
+
+In `["NORTH", "SOUTH", "EAST", "WEST"]`, the direction `"NORTH" + "SOUTH"` is going north and coming back right away. What a waste of time! Better to do nothing.
+
+The path becomes `["EAST", "WEST"]`, now `"EAST"` and `"WEST"` annihilate each other, therefore, the final result is `[]` (nil in Clojure).
+
+In ["NORTH", "EAST", "WEST", "SOUTH", "WEST", "WEST"], "NORTH" and "SOUTH" are not directly opposite but they become directly opposite after the reduction of "EAST" and "WEST" so the whole path is reducible to ["WEST", "WEST"].
+
+## Task
+
+Write a function `dirReduc` which will take an array of strings and returns an array of strings with the needless directions removed (W<->E or S<->N side by side).
+
+The Haskell version takes a list of directions with `data Direction = North | East | West | South`. The Clojure version returns nil when the path is reduced to nothing. The Rust version takes a slice of `enum Direction {NORTH, SOUTH, EAST, WEST}`.
+
+## Examples
+```
+dirReduc(["NORTH", "SOUTH", "SOUTH", "EAST", "WEST", "NORTH", "WEST"]) => ["WEST"]
+dirReduc(["NORTH", "SOUTH", "SOUTH", "EAST", "WEST", "NORTH"]) => []
+```
+
+## Note
+Not all paths can be made simpler. The path ["NORTH", "WEST", "SOUTH", "EAST"] is not reducible. "NORTH" and "WEST", "WEST" and "SOUTH", "SOUTH" and "EAST" are not directly opposite of each other and can't become such. Hence the result path is itself : ["NORTH", "WEST", "SOUTH", "EAST"].
+
+_Reference:_ https://www.codewars.com/kata/directions-reduction/

ASSIGNMENTS/Don't Jump.md

@@ -0,0 +1,24 @@
+Chandu and Kundu are bored of dramatic games around. As they are very good friends and scholars they decided to discover a new game.
+In total they had N number of marbles with value inscribed on each of them from 1 to N.
+Chandu being from royal family has a treasure box. He emptied the box for the game to proceed.
+
+The game rule involved following operations :
+- Operation C : Chandu places a marble in the box. Each different marble can move inside the box only once.
+- Operation K : Kundu removes last entered marble from the box and notes down it's value on a chart.
+
+They were deciding further rules when a third person Mr. Chirp comes as a spoiler of the game. Chirp gives them a number N which is the maximum value inscribed among all marbles, and a sequence P. P can possibly be empty. In that case, in input an empty line would be there.
+
+Also, he added following restriction :
+- Kundu can perform operation K to take out a marble M only when all the marbles from values 1 to M-1 have went in the box before.
+
+Mr. Chirp kept on chirping and told Chandu and Kundu to generate the sequence of C's and K's for the chart to get filled by pattern P.
+Now, you have to help these kids before they jump out of their window in frustration.
+
+
+SAMPLE INPUT  
+41  
+6 11 8
+
+
+SAMPLE OUTPUT  
+CCCCCCKCCCCCKKKK

ASSIGNMENTS/First_Hundred_natural_no_cubic.md

@@ -0,0 +1 @@
+Task : program to find out cube of first hundred natural no's(individually) in Python.

ASSIGNMENTS/Hello world.md

@@ -1,4 +1,4 @@
-This is a simple challenge to help you practice.
+/*This is a simple challenge to help you practice.
 
 Input Format
 
@@ -7,3 +7,10 @@ You do not need to read any input in this challenge.
 Output Format
 
 Print  "Hello world".
+*/
+#include <stdio.h>
+int main()
+{
+printf("Hello world");
+return 0;
+}

ASSIGNMENTS/HelpKatekar.md

@@ -0,0 +1,25 @@
+Sartaj's partner, Katekar is very loyal to his job and also to Sartaj. In his dedication towards his duty, he often neglects his wife who ends up alone and sad. Today, katekar has promised his wife to reach home early and spend time with her. However he and Sartaj are stuck with a problem which may decide the future of Mumbai. As Katekar cannot leave in such a situation, help him to solve the problem so that he can get back to his wife. 
+
+You are given an array A of length N. You need to detemine the largest subsequence B from the given array A such that for any index i and j in B if B[i]>B[j] then the frequency of B[i] is strictly greater than the frequency of B[j].
+
+Input format :
+
+    First line : a single integer N denoting the length of given array.
+    Second line : N space seperated integers denoting the array elements.
+
+Output fromat :
+
+    Print the length of largest subsequence B that can be formed.
+
+Constraints :
+
+    1≤N≤1000
+    1≤A[i]≤1000000
+
+Sample Input:-
+5
+1 2 2 3 3
+
+
+Sample Output:-
+3