added problems from forked to main repo (#132)

* Problem 9 Palindrome Number in ruby

* [LeetCode-26] Remove duplicates from an array.

* count remaining brackets

* added missing code

* 2 more ruby questions

* begin with sorting algos

* bubble sort recursive

* bubble sort itrative

* corrected bubble sort error

* selection sort

* code to convert arr of hashes into single hash

* sort hash by key size

* rubocop fixed

* find missing number in game

* do multiply without sum * operator

* mremoved nested loop

* insertion sort incomplete

* insertion sort

* find largest sum of subarray from number array

* puting zeros at the end of the array

* fixed the code of shifting zeros at end of array

* make template for problem to solve later

* removing specials characters from array problem still in progress

* removes special character from array algo is complete

* created template to start on problem

* started problem to write algo in n time complexcity max frquency of char

* tried again but faild to make logic

* finally done max frequncy in string in n time complexcity

* template for query

* js phone shop template

* query solved

* js phone shop code

* template ready

* added questions

---------

Co-authored-by: AreebAlam99 <[email protected]>

Author: Shoaib19

Diff for: C++/put_zeros_at_end_of_array.cpp

@@ -0,0 +1,36 @@
+//  Name: Shoaib Sabir
+//  Username: Shoaib019
+//  Question: given a array of numbers move all zeros to the end of the array
+//  Approach: take two pointers one at end and one at beginning of array
+//            use while loop to terminate when both pointers colid
+//            inside loop just swap when non zero at beginning pointer
+//            and when non zero at end pointer otherwise just increase beginning pointer
+class Solution {
+public:
+    void append_zeros(int nums [],int size) {
+    int last_indx = size - 1;
+    int start_indx = 0;
+    while(start_indx < last_indx)
+    {
+      if(nums[start_indx] == 0)
+      {
+          if(nums[last_indx] == 0)
+          {
+              last_indx--;
+          }
+          else
+          {
+              nums[start_indx] = nums[last_indx];
+              nums[last_indx] = 0;
+              start_indx++;
+              last_indx--;
+          }
+          
+      }
+      else
+      {
+        start_indx++;   
+      }
+    }
+  }
+};

Diff for: C++/remove_special_characters_from_aaray.cpp

@@ -0,0 +1,53 @@
+//  Name: Shoaib Sabir
+//  Username: Shoaib019
+//  Question: remove all special characters from characters array
+//  Approach: remove_character shifts array to let by one character
+//            is_special_character checks whether character is special or not
+//            remove_special_charactes reduce size if last character is special
+//            and runs loop whenever special character finds in the array it removes
+//            find special character using is_special_character method and remove 
+//            special charactes using remove_character method
+class Solution {
+public:
+   int remove_character(char arr [], char ch, int size){
+    int i;
+    for(i=0; i< size; i++)
+    {
+        if(arr[i] == ch)
+        break;
+    }
+    if(i < size)
+    {
+        size--;
+        for(int j=i; j < size; j++)
+        {
+            arr[j] = arr[j + 1];
+        }
+        arr[size + 1] = 0;
+    }
+    return size;
+}
+
+  bool is_special_character(char ch){
+      if((!(ch >= 97 && ch <= 122) && !(ch >= 65 && ch <= 90) ))
+          return true;
+      else
+          return false;
+  }
+
+  int remove_special_charactes(char arr [],int size) {
+      if(is_special_character(arr[size - 1]))
+      {
+          size--;
+      }
+      for(int i=0; i< size; i++)
+      {
+          if(is_special_character(arr[i]))
+          {
+              size = remove_character(arr,arr[i],size);
+              i--;
+          }
+      }
+      return size;
+  }
+};

Diff for: JS/phone_shop.js

@@ -0,0 +1,45 @@
+//  Name: Shoaib Sabir
+//  Username: Shoaib019
+//  Question: find out you can afford phone or not by calculating
+//            phone price with accessories also add tax
+
+//  DATA
+TAX_RATE = 0.08;
+PHONE_PRICE = 99.99;
+ACCESSORY_PRICE = 9.99;
+SPENDING_THRESHOLD = 200;
+var bank_account_balance = 303.91;
+
+console.log(calculatePurchaseAmount()); // this is starting point
+
+function calculatePurchaseAmount() {
+  totalSpent = calculateTotalPhonePrice();
+  totalAmount = totalSpent + calculatingTax(totalSpent);
+  return formatThePrice(totalAmount);
+}
+
+function canBuy(spent){ // this function keeps some amount in bank account
+  remaining_bal = bank_account_balance - spent;
+  return remaining_bal > ACCESSORY_PRICE ? true : false;
+}
+
+function calculateTotalPhonePrice(){
+    let spent = 0;
+  while (canBuy(spent)){
+      spent += PHONE_PRICE;
+
+      if(spent < SPENDING_THRESHOLD){
+          spent += ACCESSORY_PRICE;
+      }
+  }
+  return spent;
+}
+
+
+function calculatingTax(totalSpent){
+  return totalSpent * TAX_RATE;
+}
+
+function formatThePrice(totalAmount){
+  return "Total Price: $" + String(totalAmount.toFixed(2));
+}

Diff for: MYSQL/user_name_and_count_of_invoices.sql

@@ -0,0 +1,37 @@
+-- Write an SQL query to find username and count of invoices from user and invoice table.
+
+-- Return the result table in any order.
+--  Write your MySQL query statement below
+-- create a table
+CREATE TABLE user (
+  id INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  gender TEXT NOT NULL
+);
+
+CREATE TABLE invoice (
+  id INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  total INTEGER NOT NULL,
+  user_id INTEGER,
+ FOREIGN KEY (user_id) REFERENCES user(id)
+);
+-- insert some values
+INSERT INTO user VALUES (1, 'Ryan', 'M');
+INSERT INTO user VALUES (2, 'Joanna', 'F');
+INSERT INTO user VALUES (3, 'Saul', 'M');
+INSERT INTO user VALUES (4, 'Norma', 'F');
+
+INSERT INTO invoice VALUES (1, 'backery', 99,1);
+INSERT INTO invoice VALUES (2, 'meat', 88,1);
+INSERT INTO invoice VALUES (3, 'candy', 77,3);
+INSERT INTO invoice VALUES (4, 'soaps', 66,4);
+INSERT INTO invoice VALUES (5, 'meat', 55,2);
+INSERT INTO invoice VALUES (6, 'candy', 44,2);
+INSERT INTO invoice VALUES (7, 'soaps', 33,2);
+-- fetch some values
+SELECT user.name , COUNT(*) as count
+FROM user 
+INNER JOIN invoice ON user.id = invoice.user_id
+GROUP BY user.id
+HAVING COUNT(*) > 1;

Diff for: Ruby/count_consective_numbers.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # Name: Shoaib Sabir
 # Username: Shoaib019
 # Approach: make hash count as value and number as key then find max value return its key
 def count_consective_numbers(arr)
   hash_one = {}
   arr.each do |val|
-      hash_one[val] = arr.count(val)
+    hash_one[val] = arr.count(val)
   end
-  hash_one.max_by {|k,v| v}.first
+  hash_one.max_by { |_k, v| v }.first
 end

Diff for: Ruby/count_max_letter_in_array.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Name: Shoaib Sabir
+# Username: Shoaib019
+# Approach: take hash and initialize it with zero run loop over string
+#           increase count every time in hash key which is character
+#           then use max_by built in method to find letter with max count
+def find_max_frequency_character(str)
+  hash = Hash.new(0)
+  str.each_char do |ch|
+    hash[ch] += 1
+  end
+  hash.max_by { |_, v| v }.first
+end

Diff for: Ruby/count_remaining_brackets.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # Name: Shoaib Sabir
 # Username: Shoaib019
 # Approach: deduct open from close bracket to get remaining brackets
 def count_remaining_brackets(str)
-	open_brackets = str.count('(')
-    close_brackets = str.count(')')
-    remaining  = open_brackets - close_brackets
-    remaining.negative? ? remaining.abs : remaining
-end
+  open_brackets = str.count('(')
+  close_brackets = str.count(')')
+  remaining = open_brackets - close_brackets
+  remaining.negative? ? remaining.abs : remaining
+end

Diff for: Ruby/fizzbuzz.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 # Name: Shoaib Sabir
 # Username: Shoaib019
-# Approach: loop runs n times for each element and checks for appropriate conditions
-def fizz_buzz(n)
-	arr = []
-		(1..n).each do |num|
-			if (num.modulo(3).zero? && num.modulo(5).zero?) then arr << "FizzBuzz"
-			elsif num.modulo(3).zero? then arr << "Fizz"
-			elsif num.modulo(5).zero? then arr << "Buzz"
-			else arr << num.to_s
-			end
-		end
-	arr
-end
+# Approach: loop runs number times for each element and checks for appropriate conditions
+def fizz_buzz(number)
+  arr = []
+  (1..number).each do |num|
+    arr << if num.modulo(3).zero? && num.modulo(5).zero? then 'FizzBuzz'
+           elsif num.modulo(3).zero? then 'Fizz'
+           elsif num.modulo(5).zero? then 'Buzz'
+           else
+             num.to_s
+           end
+  end
+  arr
+end

Diff for: Ruby/inventing_multiplication.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Name: Shoaib Sabir
+# Username: Shoaib019
+# Question: do multiplication without * operator
+def inventing_multiplication(num1, num2)
+  res = 0
+  num2.times.each do |_num|
+    res += num1
+  end
+  res
+end

Diff for: Ruby/jump_tiles.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 # Name: Shoaib Sabir
 # Username: Shoaib019
+# Question: jump n times where n is current number in array and find did you able to reach to end of array
 # Approach: in loop added only those elements on which pointer value is same
 #           then compare pointer value with size of array
 def jump_tiles(arr)
-    pointer = 0
-	arr.each_with_index do |_,idx|
-	    pointer = pointer + arr[idx] if pointer == idx
-	end
-	pointer >= arr.length - 1 ? true : false
-end
+  pointer = 0
+  arr.each_with_index do |_, idx|
+    pointer += arr[idx] if pointer == idx
+  end
+  pointer >= arr.length - 1
+end

Diff for: Ruby/largest_sum.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+def largest_sum; end

Diff for: Ruby/largest_sum_of_numbers_subarray.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Name: Shoaib Sabir
+# Username: Shoaib019
+# Approach:
+def largest_sum(arr)
+  # code here
+end

Diff for: Ruby/make_one_hash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+def make_one_hash(arr)
+  hash = {}
+  arr.each do |ele|
+    hash.merge!(ele)
+  end
+  hash
+end
+
+arr = [{ a: 3, b: 2, c: 3, d: 4 }, { e: 3, f: 2 }, { g: 2, h: 3 }]
+puts make_one_hash(arr)

Diff for: Ruby/missing_game_number.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Name: Shoaib Sabir
+# Username: Shoaib019
+# Question: find missing number in array
+def missing_game_number(arr)
+  (1..10).each do |num|
+    arr << num if arr.exclude?(num)
+  end
+  arr.sort
+end

Diff for: Ruby/palindrome_number.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 # Name: Areeb Alam
 # Username: AreebAlam99
 # Approach: Converted the number into an array of digits and checked if it was equal to its reverse or not.
 
-def is_palindrome(x)
-  return false if x < 0
-  x.digits == x.digits.reverse ? true : false
+def palindrome?(num)
+  return false if num.negative?
+
+  num.digits == num.digits.reverse
 end

Diff for: Ruby/remove_duplicates_from_array.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Name: Areeb Alam
 # Username: AreebAlam99
 # Approach: Just used uniq to remove duplicates and returned count :p.

Diff for: Ruby/sort_hash_by_key_size.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+hash = { "abcd": 4, "abc": 3, "abcdf": 5, "ab": 2 }
+puts Hash[hash.sort_by { |k, _| k.size }]

Diff for: sorting_algos/bubble_sort.cpp

@@ -0,0 +1,35 @@
+// recursive approach
+
+void bubble_sort(int arr[],int size)
+{ 
+    if (size == 0 || size == 1)
+        return;
+    for(int i = 0; i < size - 1 ; i++)
+    {
+        if(arr[i] > arr[i + 1])
+        {
+            int temp = arr[i];
+            arr[i] = arr[i + 1];
+            arr[i + 1] = temp;
+        }
+    }
+    bubble_sort(arr, size - 1);
+}
+
+// itrative approach
+void bubble_sort(int arr[],int size)
+{ 
+    for(int i = 0; i < size - 1 ; i++)
+    {
+        for(int j = 0; j < size - i - 1; j++)
+        {
+            if(arr[j] > arr[j + 1])
+            {
+                int temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+            }
+            
+        }
+    }
+}