doc: Added README.md

* Added README.md
* Added .gitignore
* Added 4 Leetcode problem solutions

Author: ralvarezdev

.gitignore

@@ -0,0 +1,5 @@
+# jetbrains' ides
+.idea/
+
+# vscode
+.vscode/

.idea/.gitignore

@@ -0,0 +1,23 @@
+# Leetcode
+
+This repository contains my solutions to Leetcode problems, which I have solved using multiple programming languages.
+
+You can visit my profile [here](https://leetcode.com/ralvarezdev/).
+
+## Developers
+
+- [ralvarezdev](https://github.com/ralvarezdev) - Ramón Álvarez
+
+## Programming Languages
+
+- Python
+- JavaScript
+- Java
+- SQL
+
+## Sections
+
+- [30 Days of JavaScript](30-days-of-javascript)
+- [Top SQL 50](top-sql-50)
+- [Daily Challenges](monthly)
+- [Random Challenges](random)

README.md

@@ -0,0 +1,36 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+var luckyNumbers  = function(matrix) {
+    const minMap = new Map(), maxMap = new Map()
+
+    for(let i=0, j, min;i<matrix.length;i++){
+        min = matrix[i][0]
+
+        for(j=1;j<matrix[i].length;j++)
+            if(matrix[i][j]<min)
+                min=matrix[i][j]
+
+        minMap.set(min, true)
+    }
+
+    for(let i=0,j,max;i<matrix[0].length;i++)
+    {
+        max =matrix[0][i]
+
+        for(j=1;j<matrix.length;j++)
+            if(matrix[j][i]>max)
+                max=matrix[j][i]
+
+        maxMap.set(max, true)
+    }
+
+    const result =[]
+
+    for(let key of minMap.keys())
+        if(minMap.get(key)&&maxMap.get(key))
+            result.push(key)
+
+    return result
+};

monthly/2024-july/easy/lucky-numbers-in-a-matrix.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var frequencySort = function(nums) {
+    const numsSorted = new Array(nums.length), numsMap=new Map(), frequencyMap=new Map()
+    let frequencyList=[], numsList, frequency
+
+    for(let num of nums){
+        frequency = numsMap.get(num)
+
+        if(frequency===undefined)
+            numsMap.set(num, 1)
+        else
+            numsMap.set(num, frequency+1)
+    }
+
+    for(let num of numsMap.keys()){
+        frequency=numsMap.get(num)
+        numsList=frequencyMap.get(frequency)
+
+        if(numsList===undefined){
+            frequencyMap.set(frequency, [num])
+            frequencyList.push(frequency)
+        }
+        else
+            numsList.push(num)
+    }
+
+    frequencyList.sort((a,b)=>a-b)
+
+    for(let i=0,j=0,k,l,num;j<frequencyList.length;j++)
+        {
+            frequency=frequencyList[j]
+            numsList=frequencyMap.get(frequency)
+            numsList.sort((a,b)=>b-a)
+
+            for(k=0;k<numsList.length;k++)
+                for(l=0;l<frequency;l++)
+                    numsSorted[i++]=numsList[k]
+        }
+
+    console.log(frequencyList, frequencyMap)
+
+    return numsSorted
+};

monthly/2024-july/easy/sort-array-by-increasing-frequency.js

@@ -0,0 +1,41 @@
+/**
+ * @param {string[]} names
+ * @param {number[]} heights
+ * @return {string[]}
+ */
+var sortPeople = function(names, heights) {
+    const searchInsert = (nums, target)=> {
+    let low = 0, high = nums.length - 1, mid, isUpper
+
+    while (high >= low) {
+        mid = Math.floor((high + low) / 2)
+
+        if (nums[mid] === target)
+            return mid
+
+        else if (nums[mid] < target) {
+            high = mid - 1
+            isUpper = false
+        } else {
+            low = mid + 1
+            isUpper = true
+        }
+    }
+
+    return isUpper ? mid + 1 : mid
+}
+
+    const sortedHeights=[], sortedNames=[]
+    let i, h, n
+
+    while(names.length>0&&heights.length>0)
+    {
+        h = heights.pop()
+        n= names.pop()
+        i=searchInsert(sortedHeights, h)
+        sortedHeights.splice(i, 0, h)
+        sortedNames.splice(i,0,n)
+    }
+
+    return sortedNames
+};

monthly/2024-july/easy/sort-the-people.js

@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var sortArray = function(nums) {
+    const sortedNums=[nums.pop()]
+
+    const binarySearchInsert=num=>{
+            let low=0,high=sortedNums.length-1, mid,isUpper=false
+
+            while(high>=low){
+                mid = Math.floor((high+low)/2)
+
+                if(sortedNums[mid]===num)
+                    return mid
+
+                else if(sortedNums[mid]>num)
+                {
+                    high=mid-1
+                    isUpper=false
+                }
+
+                else{
+                    low=mid+1
+                    isUpper=true
+                }
+            }
+
+            return isUpper?mid+1:mid
+    }
+
+    let num, idx
+
+    while(nums.length>0){
+        num = nums.pop()
+        idx=binarySearchInsert(num)
+        sortedNums.splice(idx,0,num)
+    }
+    return sortedNums
+};

monthly/2024-july/medium/sort-an-array-solution1.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var sortArray = function(nums) {
+   const merge = (leftArr,rightArr)=>{
+        const arr=[]
+
+        while(leftArr.length>0&&rightArr.length>0)
+            if(leftArr[0]>=rightArr[0])
+                arr.push(rightArr.shift())
+            else
+                arr.push(leftArr.shift())
+
+        return [...arr,...leftArr,...rightArr]
+   }
+
+   const mergeSort=arr=>{
+        if(arr.length===1)
+            return arr
+
+        const half=Math.floor(arr.length/2)
+        const leftArr=arr.splice(half)
+
+        return merge(mergeSort(leftArr),mergeSort(arr))
+   }
+
+   return mergeSort(nums)
+};