feat: add solutions to lc problems: No.0526,1592

- No.0526.Beautiful Arrangement
- No.1592.Rearrange Spaces Between Words

Author: YangFong

solution/0500-0599/0526.Beautiful Arrangement/README.md

@@ -225,6 +225,76 @@ func countArrangement(n int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countArrangement(n: number): number {
+    const vis = new Array(n + 1).fill(0);
+    const match = Array.from({ length: n + 1 }, () => []);
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (i % j === 0 || j % i === 0) {
+                match[i].push(j);
+            }
+        }
+    }
+
+    let res = 0;
+    const dfs = (i: number, n: number) => {
+        if (i === n + 1) {
+            res++;
+            return;
+        }
+        for (const j of match[i]) {
+            if (!vis[j]) {
+                vis[j] = true;
+                dfs(i + 1, n);
+                vis[j] = false;
+            }
+        }
+    };
+    dfs(1, n);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: usize, n: usize, mat: &Vec<Vec<usize>>, vis: &mut Vec<bool>, res: &mut i32) {
+        if i == n + 1 {
+            *res += 1;
+            return;
+        }
+        for &j in mat[i].iter() {
+            if !vis[j] {
+                vis[j] = true;
+                Self::dfs(i + 1, n, mat, vis, res);
+                vis[j] = false;
+            }
+        }
+    }
+
+    pub fn count_arrangement(n: i32) -> i32 {
+        let n = n as usize;
+        let mut vis = vec![false; n + 1];
+        let mut mat = vec![Vec::new(); n + 1];
+        for i in 1..=n {
+            for j in 1..=n {
+                if i % j == 0 || j % i == 0 {
+                    mat[i].push(j);
+                }
+            }
+        }
+
+        let mut res = 0;
+        Self::dfs(1, n, &mat, &mut vis, &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0500-0599/0526.Beautiful Arrangement/README_EN.md

@@ -213,6 +213,76 @@ func countArrangement(n int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countArrangement(n: number): number {
+    const vis = new Array(n + 1).fill(0);
+    const match = Array.from({ length: n + 1 }, () => []);
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (i % j === 0 || j % i === 0) {
+                match[i].push(j);
+            }
+        }
+    }
+
+    let res = 0;
+    const dfs = (i: number, n: number) => {
+        if (i === n + 1) {
+            res++;
+            return;
+        }
+        for (const j of match[i]) {
+            if (!vis[j]) {
+                vis[j] = true;
+                dfs(i + 1, n);
+                vis[j] = false;
+            }
+        }
+    };
+    dfs(1, n);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: usize, n: usize, mat: &Vec<Vec<usize>>, vis: &mut Vec<bool>, res: &mut i32) {
+        if i == n + 1 {
+            *res += 1;
+            return;
+        }
+        for &j in mat[i].iter() {
+            if !vis[j] {
+                vis[j] = true;
+                Self::dfs(i + 1, n, mat, vis, res);
+                vis[j] = false;
+            }
+        }
+    }
+
+    pub fn count_arrangement(n: i32) -> i32 {
+        let n = n as usize;
+        let mut vis = vec![false; n + 1];
+        let mut mat = vec![Vec::new(); n + 1];
+        for i in 1..=n {
+            for j in 1..=n {
+                if i % j == 0 || j % i == 0 {
+                    mat[i].push(j);
+                }
+            }
+        }
+
+        let mut res = 0;
+        Self::dfs(1, n, &mat, &mut vis, &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0500-0599/0526.Beautiful Arrangement/Solution.rs

@@ -0,0 +1,32 @@
+impl Solution {
+    fn dfs(i: usize, n: usize, mat: &Vec<Vec<usize>>, vis: &mut Vec<bool>, res: &mut i32) {
+        if i == n + 1 {
+            *res += 1;
+            return;
+        }
+        for &j in mat[i].iter() {
+            if !vis[j] {
+                vis[j] = true;
+                Self::dfs(i + 1, n, mat, vis, res);
+                vis[j] = false;
+            }
+        }
+    }
+
+    pub fn count_arrangement(n: i32) -> i32 {
+        let n = n as usize;
+        let mut vis = vec![false; n + 1];
+        let mut mat = vec![Vec::new(); n + 1];
+        for i in 1..=n {
+            for j in 1..=n {
+                if i % j == 0 || j % i == 0 {
+                    mat[i].push(j);
+                }
+            }
+        }
+
+        let mut res = 0;
+        Self::dfs(1, n, &mat, &mut vis, &mut res);
+        res
+    }
+}

solution/0500-0599/0526.Beautiful Arrangement/Solution.ts

@@ -0,0 +1,28 @@
+function countArrangement(n: number): number {
+    const vis = new Array(n + 1).fill(0);
+    const match = Array.from({ length: n + 1 }, () => []);
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (i % j === 0 || j % i === 0) {
+                match[i].push(j);
+            }
+        }
+    }
+
+    let res = 0;
+    const dfs = (i: number, n: number) => {
+        if (i === n + 1) {
+            res++;
+            return;
+        }
+        for (const j of match[i]) {
+            if (!vis[j]) {
+                vis[j] = true;
+                dfs(i + 1, n);
+                vis[j] = false;
+            }
+        }
+    };
+    dfs(1, n);
+    return res;
+}

solution/1500-1599/1592.Rearrange Spaces Between Words/README.md

@@ -128,6 +128,62 @@ func reorderSpaces(text string) string {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function reorderSpaces(text: string): string {
+    let count = 0;
+    for (const c of text) {
+        if (c === ' ') {
+            count++;
+        }
+    }
+
+    const words = text.trim().split(/\s+/g);
+    const n = words.length;
+    if (n === 1) {
+        return words.join('') + ''.padStart(count);
+    }
+
+    const rest = count % (words.length - 1);
+    const per = (count - rest) / (words.length - 1);
+    return words.join(''.padStart(per)) + ''.padStart(rest);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn create_spaces(n: usize) -> String {
+        let mut res = String::new();
+        for _ in 0..n {
+            res.push(' ');
+        }
+        res
+    }
+
+    pub fn reorder_spaces(text: String) -> String {
+        let count = {
+            let mut res = 0;
+            for c in text.as_bytes() {
+                if c == &b' ' {
+                    res += 1;
+                }
+            }
+            res
+        };
+
+        let works = text.split_whitespace().collect::<Vec<&str>>();
+        let n = works.len();
+        if n == 1 {
+            return works[0].to_string() + &Self::create_spaces(count);
+        }
+        works.join(&Self::create_spaces((count / (n - 1)))) + &Self::create_spaces(count % (n - 1))
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1500-1599/1592.Rearrange Spaces Between Words/README_EN.md

@@ -96,6 +96,62 @@ func reorderSpaces(text string) string {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function reorderSpaces(text: string): string {
+    let count = 0;
+    for (const c of text) {
+        if (c === ' ') {
+            count++;
+        }
+    }
+
+    const words = text.trim().split(/\s+/g);
+    const n = words.length;
+    if (n === 1) {
+        return words.join('') + ''.padStart(count);
+    }
+
+    const rest = count % (words.length - 1);
+    const per = (count - rest) / (words.length - 1);
+    return words.join(''.padStart(per)) + ''.padStart(rest);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn create_spaces(n: usize) -> String {
+        let mut res = String::new();
+        for _ in 0..n {
+            res.push(' ');
+        }
+        res
+    }
+
+    pub fn reorder_spaces(text: String) -> String {
+        let count = {
+            let mut res = 0;
+            for c in text.as_bytes() {
+                if c == &b' ' {
+                    res += 1;
+                }
+            }
+            res
+        };
+
+        let works = text.split_whitespace().collect::<Vec<&str>>();
+        let n = works.len();
+        if n == 1 {
+            return works[0].to_string() + &Self::create_spaces(count);
+        }
+        works.join(&Self::create_spaces((count / (n - 1)))) + &Self::create_spaces(count % (n - 1))
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1500-1599/1592.Rearrange Spaces Between Words/Solution.rs

@@ -0,0 +1,28 @@
+impl Solution {
+    fn create_spaces(n: usize) -> String {
+        let mut res = String::new();
+        for _ in 0..n {
+            res.push(' ');
+        }
+        res
+    }
+
+    pub fn reorder_spaces(text: String) -> String {
+        let count = {
+            let mut res = 0;
+            for c in text.as_bytes() {
+                if c == &b' ' {
+                    res += 1;
+                }
+            }
+            res
+        };
+
+        let works = text.split_whitespace().collect::<Vec<&str>>();
+        let n = works.len();
+        if n == 1 {
+            return works[0].to_string() + &Self::create_spaces(count);
+        }
+        works.join(&Self::create_spaces((count / (n - 1)))) + &Self::create_spaces(count % (n - 1))
+    }
+}

solution/1500-1599/1592.Rearrange Spaces Between Words/Solution.ts

@@ -0,0 +1,18 @@
+function reorderSpaces(text: string): string {
+    let count = 0;
+    for (const c of text) {
+        if (c === ' ') {
+            count++;
+        }
+    }
+
+    const words = text.trim().split(/\s+/g);
+    const n = words.length;
+    if (n === 1) {
+        return words.join('') + ''.padStart(count);
+    }
+
+    const rest = count % (words.length - 1);
+    const per = (count - rest) / (words.length - 1);
+    return words.join(''.padStart(per)) + ''.padStart(rest);
+}