Typescript solutions

solutions/015.md

@@ -50,6 +50,22 @@ class Solution:
         return total
 
 ```
+### Solution in Typescript
+
+```typescript
+
+function sumOfMultiples(n: number): number {
+    let sum = 0;
+    for(let i = 0; i <= n; i++) {
+        if((i % 3 === 0) || (i % 5 === 0) || (i % 7 === 0)) {
+            sum += i;
+        }
+    }
+    return sum;
+}
+
+```
+
 
 #### TypeScript
 

solutions/017.md

@@ -46,6 +46,19 @@ class Solution:
     def defangIPaddr(self, address: str) -> str:
         return "[.]".join(address.split("."))
 ```
+# Typescript
+
+```typescript
+
+function defangIPaddr(address: string): string {
+    let result = '';
+    for(let i = 0; i < address.length; i++) {
+        result += address[i] === '.' ? '[.]' : address[i]
+    }
+    return result;
+};
+
+```
 
 #### TypeScript
 **Please suggest a better version of this code.** 

solutions/019.md

@@ -76,5 +76,16 @@ class Solution:
                 total += 1
         return total
 ```
+#### TypeScript
+
+``` typescript
+function finalValueAfterOperations(operations: string[]): number {
+    let res = 0
+    for(let operation of operations){
+        operation[1] === '+' ? res++ : res--
+    }
+    return res;
+};
+```
 
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/021.md

@@ -72,5 +72,15 @@ class Solution:
         greatest = max(candies)
         return [extraCandies+candy >= greatest for candy in candies]
 ```
+#### TypeScript
 
+``` typescript
+function kidsWithCandies(candies: number[], extraCandies: number): boolean[] {
+    return candies.map(candy => isGreaterAll(candies, candy + extraCandies));
+};
+
+function isGreaterAll(array: number[], value: number): boolean {
+    return array.every(item => item <= value)
+}  
+```
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/022.md

@@ -76,5 +76,32 @@ class Solution:
             result.append(array)
         return result
 ```
-
+#### TypeScript
+
+``` typescript
+function findMatrix(nums: number[]): number[][] {
+    const result: number[][] = [];
+    const numberMap: Record<number, number> = {};
+    let count = 1;
+    for(let num of nums) {
+        if(numberMap[num]) {
+            numberMap[num] = numberMap[num] + 1
+        } else {
+            numberMap[num] = 1
+        }
+    }
+
+    while(count <= Math.max(...Object.values(numberMap))) {
+        const subArray: number[] = []
+        for(let key of Object.keys(numberMap)){
+            if(numberMap[key] >= count) {
+                subArray.push(Number(key))
+            }
+        }
+        result.push(subArray)
+        count++
+    }
+    return result;
+};
+```
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/023.md

@@ -64,4 +64,13 @@ class Solution:
         return max(sum(account) for account in accounts) 
 ```
 
+#### TypeScript
+
+``` typescript
+function maximumWealth(accounts: number[][]): number {
+    let wealthes = accounts.map(account => account.reduce((a, b) => a + b, 0))
+    return Math.max(...wealthes);
+};
+```
+
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/024.md

@@ -137,4 +137,27 @@ class SubrectangleQueries:
 # param_2 = obj.getValue(row,col)
 ```
 
+#### TypeScript
+
+``` typescript
+class SubrectangleQueries {
+    rectangle:number[][];
+    constructor(rectangle: number[][]) {
+        this.rectangle = rectangle
+    }
+
+    updateSubrectangle(row1: number, col1: number, row2: number, col2: number, newValue: number): void {
+        for(let i = row1; i <= row2; i++) {
+            for(let j = col1; j <= col2; j++) {
+                this.rectangle[i][j] = newValue
+            }
+        }
+    }
+
+    getValue(row: number, col: number): number {
+        return this.rectangle[row][col]
+    }
+}
+```
+
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/025.md

@@ -64,4 +64,11 @@ class Solution:
         return nums
 ```
 
+#### TypeScript
+
+``` typescript
+function getConcatenation(nums: number[]): number[] {
+    return nums.concat(nums)
+};
+```
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/026.md

@@ -100,4 +100,22 @@ class Solution:
         return result
 ```
 
+#### TypeScript
+
+``` typescript
+function minOperations(boxes: string): number[] {
+    const result: number[] = [];
+    for(let i = 0; i < boxes.length; i++) {
+        let steps = 0;
+        for(let j = 0; j< boxes.length; j++) {
+            if(+boxes[j] && j !== i) {
+                steps += Math.abs(j - i);
+            }
+        }
+        result.push(steps)
+    }
+    return result;
+};
+```
+
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/027.md

@@ -81,6 +81,28 @@ class Solution:
             left_sum -= num
         return answer
 ```
-
+#### TypeScript
+
+``` typescript
+function leftRightDifference(nums: number[]): number[] {
+    const answer = [];
+    const rightSums = [];
+    const leftSums = [];
+    const length = nums.length;
+    for(let i = 0; i < nums.length; i++) {
+        if(i === 0) {
+            leftSums.push(0);
+            rightSums.push(0);
+        } else {
+            leftSums.push(leftSums[i - 1] + nums[i - 1]);
+            rightSums.unshift(nums[nums.length - i] + rightSums[0])
+        }
+    }
+    for(let i = 0; i < length; i++) {
+        answer[i] = Math.abs(leftSums[i] - rightSums[i])
+    }
+    return answer
+};
+```
 
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/029.md

@@ -70,4 +70,11 @@ class Solution:
 
 explnation_here
 
+#### TypeScript
+
+``` typescript
+function mostWordsFound(sentences: string[]): number {
+    return Math.max(...sentences.map(item => item.split(' ').length))
+};
+```
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/030.md

@@ -70,4 +70,23 @@ class Solution:
         return answer
 ```
 
+#### TypeScript
+
+``` typescript
+function findArray(pref: number[]): number[] {
+    const result: number[] = [];
+    let pre = 0;
+    for(let i = 0; i < pref.length; i++) {
+        if(i === 0) {
+            result.push(pref[0])
+        } else {
+            pre ^= result[i - 1] 
+            result.push(pre ^ pref[i])
+        }
+    }
+    return result;
+};
+
+```
+
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/031.md

@@ -63,4 +63,16 @@ class Solution:
         return result
 ```
 
+#### TypeScript
+
+``` typescript
+function xorOperation(n: number, start: number): number {
+    let res = 0;
+    for(let i = 0; i<n; i++) {
+        res ^= start + 2 * i;
+    }
+    return res
+};
+```
+
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.

solutions/032.md

@@ -65,12 +65,19 @@ The sortTheStudents method takes a `list` of lists called `score`, where each in
 
 In summary, the code sorts the `score` list of students based on a specific score index `k` in descending order. The time complexity is typically O(n log n), and the space complexity is O(1).
 
-#### Ptyhon3
+#### Python3
 
 ```python3
 class Solution:
     def sortTheStudents(self, score: List[List[int]], k: int) -> List[List[int]]:
         return sorted(score, key=lambda x: x[k], reverse=True)
 ```
+#### TypeScript
+
+``` typescript
+function sortTheStudents(score: number[][], k: number): number[][] {
+    return score.sort((a, b) => b[k]- a[k]);
+};
+```
 
 ***NB***: If you want to get community points please suggest solutions in other languages as merge requests.