add math solutions

Author: Meera Parmar

src/arrays/SortColors.java

@@ -0,0 +1,31 @@
+package arrays;
+/*
+ * https://leetcode.com/problems/sort-colors/
+ * Sort Colors:
+ * Given an array with n objects colored red, white or blue, sort them in-place so that objects of 
+ * the same color are adjacent, with the colors in the order red, white and blue.
+ * Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+ */
+public class SortColors {
+public void sortColors(int[] nums) {
+int i=0,j=0,k=nums.length-1;
+while(j<=k){
+if(nums[j]==0){
+int temp=nums[i];
+nums[i]=nums[j];
+nums[j]=temp;
+i++;
+j++;
+}
+else if(nums[j]==2){
+int temp=nums[j];
+nums[j]=nums[k];
+nums[k]=temp;
+k--;
+}
+else{
+j++;
+}
+}
+}
+}

src/graphs/FindTheCelebrity.java

@@ -0,0 +1,47 @@
+package graphs;
+/*
+ * https://leetcode.com/problems/find-the-celebrity/
+ * Find the Celebrity:
+ * Suppose you are at a party with n people (labeled from 0 to n - 1) and among them, 
+ * there may exist one celebrity. The definition of a celebrity is that all the other n - 1 
+ * people know him/her but he/she does not know any of them.
+ * Now you want to find out who the celebrity is or verify that there is not one. 
+ * The only thing you are allowed to do is to ask questions like: "Hi, A. Do you know B?" 
+ * to get information of whether A knows B. You need to find out the celebrity 
+ * (or verify there is not one) by asking as few questions as possible (in the asymptotic sense).
+ * You are given a helper function bool knows(a, b) which tells you whether A knows B. 
+ * Implement a function int findCelebrity(n). There will be exactly one celebrity if he/she is 
+ * in the party. Return the celebrity's label if there is a celebrity in the party. 
+ * If there is no celebrity, return -1.
+ */
+public class FindTheCelebrity extends Relation{
+public int findCelebrity(int n) {
+int celeb = 0;
+for(int i=0;i<n;i++){
+if(knows(celeb, i)){
+celeb=i;
+}
+}
+if(isCeleb(n,celeb)){
+return celeb;
+}
+return -1;
+}
+
+private boolean isCeleb(int n, int celeb){
+for(int j=0;j<n;j++){
+if(celeb!=j){
+if(!knows(j, celeb) || knows(celeb, j)){
+return false;
+}
+}
+}
+return true;
+}
+}
+
+class Relation{
+boolean knows(int a, int b) {
+return true;
+}
+}

src/arrays/AddBinary.java src/math/AddBinary.javasrc/arrays/AddBinary.java renamed to src/math/AddBinary.java

@@ -1,4 +1,4 @@
-package arrays;
+package math;
 /*
  * https://leetcode.com/problems/add-binary/
  * Add Binary:

src/math/CountingBits.java

@@ -0,0 +1,29 @@
+package math;
+/*
+ * 
+ * Counting Bits:
+ * Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num 
+ * calculate the number of 1's in their binary representation and return them as an array.
+ */
+public class CountingBits {
+public int[] countBits(int num) {
+int result[]=new int[num+1];
+result[0]=0;
+
+int twoN=1;
+int count=1;
+for(int i=1;i<=num;i++){
+if(i==twoN){
+twoN=twoN<<1;
+count=1;
+result[i]=1;
+}
+else{
+result[i]=result[count]+1;
+count++;
+}
+}
+return result;
+
+}
+}

…sorting_searching/DivideTwoIntegers.java src/math/DivideTwoIntegers.javasrc/sorting_searching/DivideTwoIntegers.java renamed to src/math/DivideTwoIntegers.java src/sorting_searching/DivideTwoIntegers.java renamed to src/math/DivideTwoIntegers.java

@@ -1,4 +1,4 @@
-package sorting_searching;
+package math;
 /*
  * https://leetcode.com/problems/divide-two-integers/
  * 

src/math/FractionToRecurringDecimal.java

@@ -0,0 +1,51 @@
+package math;
+
+import java.util.HashMap;
+
+/*
+ * https://leetcode.com/problems/fraction-to-recurring-decimal/
+ * Fraction to Recurring Decimal:
+ * Given two integers representing the numerator and denominator of a fraction, 
+ * return the fraction in string format.
+ * If the fractional part is repeating, enclose the repeating part in parentheses.
+ */
+public class FractionToRecurringDecimal {
+public String fractionToDecimal(int numerator, int denominator) {
+if(numerator==0){
+return "0";
+}
+if(denominator==0){
+return "";
+}
+
+String result="";
+if((numerator<0) ^ (denominator<0)){
+result+='-';
+}
+long num=numerator;
+long den=denominator;
+num=Math.abs(num);
+den=Math.abs(den);
+long q=num/den;
+long r=num%den;
+result+=q;
+if(r==0){
+return result;
+}
+result+=".";
+r=r*10;
+HashMap<Long,Integer> map=new HashMap<>();
+while(r!=0){
+if(map.containsKey(r)){
+int b=map.get(r);
+return (result.substring(0,b)+"("+result.substring(b, result.length())+")");
+}
+map.put(r, result.length());
+q=r/den;
+result+=q;
+r=(r%den)*10;
+}
+return result;
+
+}
+}

src/strings/MultiplyStrings.java src/math/MultiplyStrings.javasrc/strings/MultiplyStrings.java renamed to src/math/MultiplyStrings.java

@@ -1,4 +1,4 @@
-package strings;
+package math;
 /*
  * https://leetcode.com/problems/multiply-strings/
  * Multiply Strings:

src/math/NthDigit.java

@@ -0,0 +1,25 @@
+package math;
+/*
+ * https://leetcode.com/problems/nth-digit/
+ * Nth Digit:
+ * Find the nth digit of the infinite integer sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...
+ */
+public class NthDigit {
+public int findNthDigit(int n) {
+long m=n;
+long start=1, len=1, count=9;
+while(m>len*count){
+m=m-len*count;
+count*=10;
+len++;
+start*=10;
+}
+
+start=start+(m-1)/len;
+
+String str=String.valueOf(start);
+return str.charAt((int) ((m-1)%len))-'0';
+
+
+}
+}

src/sorting_searching/PowXN.java src/math/PowXN.javasrc/sorting_searching/PowXN.java renamed to src/math/PowXN.java

@@ -1,4 +1,4 @@
-package sorting_searching;
+package math;
 /*
  * https://leetcode.com/problems/powx-n/
  * 

src/strings/RomanToInteger.java src/math/RomanToInteger.javasrc/strings/RomanToInteger.java renamed to src/math/RomanToInteger.java

@@ -1,4 +1,4 @@
-package strings;
+package math;
 /*
  * https://leetcode.com/problems/roman-to-integer/
  *