From 8894650040dde4538b0b708733dda5e662be4777 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:03:12 +0530 Subject: [PATCH 01/17] feat: add solutions to lc problems: No.3029 --- .../README.md | 103 +++++++++++++++++- 1 file changed, 101 insertions(+), 2 deletions(-) diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README.md b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README.md index 6b682e28d7534..07bd82aeb1596 100644 --- a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README.md +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README.md @@ -70,19 +70,118 @@ ```python +class Solution: + def minimumTimeToInitialState(self, word: str, k: int) -> int: + n = len(word) + for i in range(1, 10001): + re = i * k + if re >= n: + return i + if word[re:] == word[:n - re]: + return i + return 0 ``` ```java - +class Solution { + public int minimumTimeToInitialState(String word, int k) { + int n = word.length(); + for (int i = 1; i <= 10000; i++) { + int re = i * k; + if (re >= n) { + return i; + } + String str = word.substring(re); + boolean flag = true; + for (int j = 0; j < str.length(); j++) { + if (str.charAt(j) != word.charAt(j)) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; + } +} ``` ```cpp - +class Solution { +public: + int minimumTimeToInitialState(string word, int k) { + int n = word.length(); + for (int i = 1; i <= 10000; i++) { + int re = i * k; + if (re >= n) { + return i; + } + string str = word.substr(re); + bool flag = true; + for (int j = 0; j < str.length(); j++) { + if (str[j] != word[j]) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; + } +}; ``` ```go +func minimumTimeToInitialState(word string, k int) int { + n := len(word) + for i := 1; i <= 10000; i++ { + re := i * k + if re >= n { + return i + } + str := word[re:] + flag := true + for j := 0; j < len(str); j++ { + if str[j] != word[j] { + flag = false + break + } + } + if flag { + return i + } + } + return 0 +} +``` +```ts +function minimumTimeToInitialState(word: string, k: number): number { + const n = word.length; + for (let i = 1; i <= 10000; i++) { + const re = i * k; + if (re >= n) { + return i; + } + const str = word.substring(re); + let flag = true; + for (let j = 0; j < str.length; j++) { + if (str[j] !== word[j]) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; +} ``` From 9dcbbfd3f57beae67d0ec9178adbe20349256641 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:04:37 +0530 Subject: [PATCH 02/17] feat: add solutions to lc problems: No.3029 --- .../README_EN.md | 103 +++++++++++++++++- 1 file changed, 101 insertions(+), 2 deletions(-) diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README_EN.md b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README_EN.md index c0808e1e03619..7aa1f3dd01549 100644 --- a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README_EN.md +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README_EN.md @@ -63,19 +63,118 @@ It can be shown that 4 seconds is the minimum time greater than zero required fo ```python +class Solution: + def minimumTimeToInitialState(self, word: str, k: int) -> int: + n = len(word) + for i in range(1, 10001): + re = i * k + if re >= n: + return i + if word[re:] == word[:n - re]: + return i + return 0 ``` ```java - +class Solution { + public int minimumTimeToInitialState(String word, int k) { + int n = word.length(); + for (int i = 1; i <= 10000; i++) { + int re = i * k; + if (re >= n) { + return i; + } + String str = word.substring(re); + boolean flag = true; + for (int j = 0; j < str.length(); j++) { + if (str.charAt(j) != word.charAt(j)) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; + } +} ``` ```cpp - +class Solution { +public: + int minimumTimeToInitialState(string word, int k) { + int n = word.length(); + for (int i = 1; i <= 10000; i++) { + int re = i * k; + if (re >= n) { + return i; + } + string str = word.substr(re); + bool flag = true; + for (int j = 0; j < str.length(); j++) { + if (str[j] != word[j]) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; + } +}; ``` ```go +func minimumTimeToInitialState(word string, k int) int { + n := len(word) + for i := 1; i <= 10000; i++ { + re := i * k + if re >= n { + return i + } + str := word[re:] + flag := true + for j := 0; j < len(str); j++ { + if str[j] != word[j] { + flag = false + break + } + } + if flag { + return i + } + } + return 0 +} +``` +```ts +function minimumTimeToInitialState(word: string, k: number): number { + const n = word.length; + for (let i = 1; i <= 10000; i++) { + const re = i * k; + if (re >= n) { + return i; + } + const str = word.substring(re); + let flag = true; + for (let j = 0; j < str.length; j++) { + if (str[j] !== word[j]) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; +} ``` From 2b54b895a951b1a22544cbc11c7ad02179b3f36c Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:05:28 +0530 Subject: [PATCH 03/17] feat: add solutions to lc problems: No.3029 --- .../Solution.cpp | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.cpp diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.cpp b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.cpp new file mode 100644 index 0000000000000..58457d00178a5 --- /dev/null +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.cpp @@ -0,0 +1,24 @@ +class Solution { +public: + int minimumTimeToInitialState(string word, int k) { + int n = word.length(); + for (int i = 1; i <= 10000; i++) { + int re = i * k; + if (re >= n) { + return i; + } + string str = word.substr(re); + bool flag = true; + for (int j = 0; j < str.length(); j++) { + if (str[j] != word[j]) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; + } +}; From 13837d6a8a4b22e5715a50b65bcf0b647bd323f0 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:06:02 +0530 Subject: [PATCH 04/17] feat: add solutions to lc problems: No.3029 --- .../Solution.go | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.go diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.go b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.go new file mode 100644 index 0000000000000..08418e0058627 --- /dev/null +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.go @@ -0,0 +1,21 @@ +func minimumTimeToInitialState(word string, k int) int { + n := len(word) + for i := 1; i <= 10000; i++ { + re := i * k + if re >= n { + return i + } + str := word[re:] + flag := true + for j := 0; j < len(str); j++ { + if str[j] != word[j] { + flag = false + break + } + } + if flag { + return i + } + } + return 0 +} From c04710b64d8295de9f8bd88929ee64d7cfdef3f0 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:06:36 +0530 Subject: [PATCH 05/17] feat: add solutions to lc problems: No.3029 --- .../Solution.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.java diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.java b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.java new file mode 100644 index 0000000000000..b29531ef7c092 --- /dev/null +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.java @@ -0,0 +1,23 @@ +class Solution { + public int minimumTimeToInitialState(String word, int k) { + int n = word.length(); + for (int i = 1; i <= 10000; i++) { + int re = i * k; + if (re >= n) { + return i; + } + String str = word.substring(re); + boolean flag = true; + for (int j = 0; j < str.length(); j++) { + if (str.charAt(j) != word.charAt(j)) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; + } +} From f6391f6e03f6c64d52d5dcd50fcae01def0e5d35 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:07:10 +0530 Subject: [PATCH 06/17] feat: add solutions to lc problems: No.3029 --- .../Solution.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py new file mode 100644 index 0000000000000..8aca0e13f8840 --- /dev/null +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py @@ -0,0 +1,10 @@ +class Solution: + def minimumTimeToInitialState(self, word: str, k: int) -> int: + n = len(word) + for i in range(1, 10001): + re = i * k + if re >= n: + return i + if word[re:] == word[:n - re]: + return i + return 0 From 874de9892b631cd401df1cac66ec42bcc4631284 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:07:39 +0530 Subject: [PATCH 07/17] feat: add solutions to lc problems: No.3029 --- .../Solution.ts | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.ts diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.ts b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.ts new file mode 100644 index 0000000000000..96a00ac553457 --- /dev/null +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.ts @@ -0,0 +1,21 @@ +function minimumTimeToInitialState(word: string, k: number): number { + const n = word.length; + for (let i = 1; i <= 10000; i++) { + const re = i * k; + if (re >= n) { + return i; + } + const str = word.substring(re); + let flag = true; + for (let j = 0; j < str.length; j++) { + if (str[j] !== word[j]) { + flag = false; + break; + } + } + if (flag) { + return i; + } + } + return 0; +} From 94959d151ae12cf0f52f48f0d7648a729752313c Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 17:14:09 +0530 Subject: [PATCH 08/17] feat: add solutions to lc problems: No.3029 --- .../Solution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py index 8aca0e13f8840..95f841995b931 100644 --- a/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py +++ b/solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py @@ -5,6 +5,6 @@ def minimumTimeToInitialState(self, word: str, k: int) -> int: re = i * k if re >= n: return i - if word[re:] == word[:n - re]: + if word[re:] == word[: n - re]: return i return 0 From a3af79a406993c76f3312c757f444f689de02ec8 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:56:05 +0530 Subject: [PATCH 09/17] feat: add solutions to lc problems: No.3031 --- .../README.md | 232 +++++++++++++++++- 1 file changed, 231 insertions(+), 1 deletion(-) diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/README.md b/solution/3000-3099/3030.Find the Grid of Region Average/README.md index 53df55efacbc5..0f9c70581e236 100644 --- a/solution/3000-3099/3030.Find the Grid of Region Average/README.md +++ b/solution/3000-3099/3030.Find the Grid of Region Average/README.md @@ -62,19 +62,249 @@ ```python +class Solution: + def resultGrid(self, image: List[List[int]], threshold: int) -> List[List[int]]: + n, m = len(image), len(image[0]) + ans = [[0] * m for _ in range(n)] + ct = [[0] * m for _ in range(n)] + + for i in range(n - 2): + for j in range(m - 2): + region = True + for k in range(3): + for l in range(2): + region &= abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold + for k in range(2): + for l in range(3): + region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold + + if region: + tot = 0 + for k in range(3): + for l in range(3): + tot += image[i + k][j + l] + for k in range(3): + for l in range(3): + ct[i + k][j + l] += 1 + ans[i + k][j + l] += tot // 9 + + for i in range(n): + for j in range(m): + if ct[i][j] == 0: + ans[i][j] = image[i][j] + else: + ans[i][j] //= ct[i][j] + + return ans ``` ```java +class Solution { + public int[][] resultGrid(int[][] image, int threshold) { + int n = image.length; + int m = image[0].length; + int[][] ans = new int[n][m]; + int[][] ct = new int[n][m]; + for (int i = 0; i + 2 < n; ++i) { + for (int j = 0; j + 2 < m; ++j) { + boolean region = true; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 2; ++l) { + region &= Math.abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (int k = 0; k < 2; ++k) { + for (int l = 0; l < 3; ++l) { + region &= Math.abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + int tot = 0; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += tot / 9; + } + } + } + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (ct[i][j] == 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] /= ct[i][j]; + } + } + } + return ans; + } +} ``` ```cpp - +class Solution { +public: + vector> resultGrid(vector>& image, int threshold) { + int n = image.size(), m = image[0].size(); + vector> ans(n, vector(m)); + vector> ct(n, vector(m)); + for (int i = 0; i + 2 < n; ++i) { + for (int j = 0; j + 2 < m; ++j) { + bool region = true; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 2; ++l) { + region &= abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (int k = 0; k < 2; ++k) { + for (int l = 0; l < 3; ++l) { + region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + int tot = 0; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += tot / 9; + } + } + } + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (ct[i][j] == 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] /= ct[i][j]; + } + } + } + return ans; + } +}; ``` ```go +func resultGrid(image [][]int, threshold int) [][]int { + n := len(image) + m := len(image[0]) + ans := make([][]int, n) + ct := make([][]int, n) + for i := range ans { + ans[i] = make([]int, m) + ct[i] = make([]int, m) + } + for i := 0; i+2 < n; i++ { + for j := 0; j+2 < m; j++ { + region := true + for k := 0; k < 3; k++ { + for l := 0; l < 2; l++ { + region = region && abs(image[i+k][j+l]-image[i+k][j+l+1]) <= threshold + } + } + for k := 0; k < 2; k++ { + for l := 0; l < 3; l++ { + region = region && abs(image[i+k][j+l]-image[i+k+1][j+l]) <= threshold + } + } + if region { + tot := 0 + for k := 0; k < 3; k++ { + for l := 0; l < 3; l++ { + tot += image[i+k][j+l] + } + } + for k := 0; k < 3; k++ { + for l := 0; l < 3; l++ { + ct[i+k][j+l]++ + ans[i+k][j+l] += tot / 9 + } + } + } + } + } + for i := 0; i < n; i++ { + for j := 0; j < m; j++ { + if ct[i][j] == 0 { + ans[i][j] = image[i][j] + } else { + ans[i][j] /= ct[i][j] + } + } + } + return ans +} +func abs(x int) int { + if x < 0 { + return -x + } + return x +} +``` + +```ts +function resultGrid(image: number[][], threshold: number): number[][] { + const n: number = image.length; + const m: number = image[0].length; + const ans: number[][] = new Array(n).fill(0).map(() => new Array(m).fill(0)); + const ct: number[][] = new Array(n).fill(0).map(() => new Array(m).fill(0)); + for (let i = 0; i + 2 < n; ++i) { + for (let j = 0; j + 2 < m; ++j) { + let region: boolean = true; + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 2; ++l) { + region &&= Math.abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (let k = 0; k < 2; ++k) { + for (let l = 0; l < 3; ++l) { + region &&= Math.abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + let tot: number = 0; + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += Math.floor(tot / 9); + } + } + } + } + } + for (let i = 0; i < n; ++i) { + for (let j = 0; j < m; ++j) { + if (ct[i][j] === 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] = Math.floor(ans[i][j] / ct[i][j]); + } + } + } + return ans; +} ``` From a9f6207736dad0a3a5ac08e2bb4fe7b87e25ad7f Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:56:20 +0530 Subject: [PATCH 10/17] feat: add solutions to lc problems: No.3030 From ed55337dc87f774fa9beb89167589cc9de413647 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:57:02 +0530 Subject: [PATCH 11/17] feat: add solutions to lc problems: No.3030 --- .../README_EN.md | 232 +++++++++++++++++- 1 file changed, 231 insertions(+), 1 deletion(-) diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md b/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md index 74a468ed6782b..6bb52279b3b61 100644 --- a/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md +++ b/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md @@ -58,19 +58,249 @@ Please note that the rounded-down values are used when calculating the average o ```python +class Solution: + def resultGrid(self, image: List[List[int]], threshold: int) -> List[List[int]]: + n, m = len(image), len(image[0]) + ans = [[0] * m for _ in range(n)] + ct = [[0] * m for _ in range(n)] + + for i in range(n - 2): + for j in range(m - 2): + region = True + for k in range(3): + for l in range(2): + region &= abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold + for k in range(2): + for l in range(3): + region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold + + if region: + tot = 0 + for k in range(3): + for l in range(3): + tot += image[i + k][j + l] + for k in range(3): + for l in range(3): + ct[i + k][j + l] += 1 + ans[i + k][j + l] += tot // 9 + + for i in range(n): + for j in range(m): + if ct[i][j] == 0: + ans[i][j] = image[i][j] + else: + ans[i][j] //= ct[i][j] + + return ans ``` ```java +class Solution { + public int[][] resultGrid(int[][] image, int threshold) { + int n = image.length; + int m = image[0].length; + int[][] ans = new int[n][m]; + int[][] ct = new int[n][m]; + for (int i = 0; i + 2 < n; ++i) { + for (int j = 0; j + 2 < m; ++j) { + boolean region = true; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 2; ++l) { + region &= Math.abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (int k = 0; k < 2; ++k) { + for (int l = 0; l < 3; ++l) { + region &= Math.abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + int tot = 0; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += tot / 9; + } + } + } + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (ct[i][j] == 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] /= ct[i][j]; + } + } + } + return ans; + } +} ``` ```cpp - +class Solution { +public: + vector> resultGrid(vector>& image, int threshold) { + int n = image.size(), m = image[0].size(); + vector> ans(n, vector(m)); + vector> ct(n, vector(m)); + for (int i = 0; i + 2 < n; ++i) { + for (int j = 0; j + 2 < m; ++j) { + bool region = true; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 2; ++l) { + region &= abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (int k = 0; k < 2; ++k) { + for (int l = 0; l < 3; ++l) { + region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + int tot = 0; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += tot / 9; + } + } + } + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (ct[i][j] == 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] /= ct[i][j]; + } + } + } + return ans; + } +}; ``` ```go +func resultGrid(image [][]int, threshold int) [][]int { + n := len(image) + m := len(image[0]) + ans := make([][]int, n) + ct := make([][]int, n) + for i := range ans { + ans[i] = make([]int, m) + ct[i] = make([]int, m) + } + for i := 0; i+2 < n; i++ { + for j := 0; j+2 < m; j++ { + region := true + for k := 0; k < 3; k++ { + for l := 0; l < 2; l++ { + region = region && abs(image[i+k][j+l]-image[i+k][j+l+1]) <= threshold + } + } + for k := 0; k < 2; k++ { + for l := 0; l < 3; l++ { + region = region && abs(image[i+k][j+l]-image[i+k+1][j+l]) <= threshold + } + } + if region { + tot := 0 + for k := 0; k < 3; k++ { + for l := 0; l < 3; l++ { + tot += image[i+k][j+l] + } + } + for k := 0; k < 3; k++ { + for l := 0; l < 3; l++ { + ct[i+k][j+l]++ + ans[i+k][j+l] += tot / 9 + } + } + } + } + } + for i := 0; i < n; i++ { + for j := 0; j < m; j++ { + if ct[i][j] == 0 { + ans[i][j] = image[i][j] + } else { + ans[i][j] /= ct[i][j] + } + } + } + return ans +} +func abs(x int) int { + if x < 0 { + return -x + } + return x +} +``` + +```ts +function resultGrid(image: number[][], threshold: number): number[][] { + const n: number = image.length; + const m: number = image[0].length; + const ans: number[][] = new Array(n).fill(0).map(() => new Array(m).fill(0)); + const ct: number[][] = new Array(n).fill(0).map(() => new Array(m).fill(0)); + for (let i = 0; i + 2 < n; ++i) { + for (let j = 0; j + 2 < m; ++j) { + let region: boolean = true; + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 2; ++l) { + region &&= Math.abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (let k = 0; k < 2; ++k) { + for (let l = 0; l < 3; ++l) { + region &&= Math.abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + let tot: number = 0; + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += Math.floor(tot / 9); + } + } + } + } + } + for (let i = 0; i < n; ++i) { + for (let j = 0; j < m; ++j) { + if (ct[i][j] === 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] = Math.floor(ans[i][j] / ct[i][j]); + } + } + } + return ans; +} ``` From e15a321c0d2e5136854726a19ea7a5cd79e2d7c7 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:57:55 +0530 Subject: [PATCH 12/17] feat: add solutions to lc problems: No.3030 --- .../Solution.cpp | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 solution/3000-3099/3030.Find the Grid of Region Average/Solution.cpp diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/Solution.cpp b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.cpp new file mode 100644 index 0000000000000..ad501b34a726b --- /dev/null +++ b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.cpp @@ -0,0 +1,47 @@ +class Solution { +public: + vector> resultGrid(vector>& image, int threshold) { + int n = image.size(), m = image[0].size(); + vector> ans(n, vector(m)); + vector> ct(n, vector(m)); + for (int i = 0; i + 2 < n; ++i) { + for (int j = 0; j + 2 < m; ++j) { + bool region = true; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 2; ++l) { + region &= abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (int k = 0; k < 2; ++k) { + for (int l = 0; l < 3; ++l) { + region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + int tot = 0; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += tot / 9; + } + } + } + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (ct[i][j] == 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] /= ct[i][j]; + } + } + } + return ans; + } +}; From 287dc8317c728a469d77bfad608aad1b895cc51b Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:58:34 +0530 Subject: [PATCH 13/17] feat: add solutions to lc problems: No.3030 --- .../Solution.go | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 solution/3000-3099/3030.Find the Grid of Region Average/Solution.go diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/Solution.go b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.go new file mode 100644 index 0000000000000..056fce5291ff4 --- /dev/null +++ b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.go @@ -0,0 +1,55 @@ +func resultGrid(image [][]int, threshold int) [][]int { + n := len(image) + m := len(image[0]) + ans := make([][]int, n) + ct := make([][]int, n) + for i := range ans { + ans[i] = make([]int, m) + ct[i] = make([]int, m) + } + for i := 0; i+2 < n; i++ { + for j := 0; j+2 < m; j++ { + region := true + for k := 0; k < 3; k++ { + for l := 0; l < 2; l++ { + region = region && abs(image[i+k][j+l]-image[i+k][j+l+1]) <= threshold + } + } + for k := 0; k < 2; k++ { + for l := 0; l < 3; l++ { + region = region && abs(image[i+k][j+l]-image[i+k+1][j+l]) <= threshold + } + } + if region { + tot := 0 + for k := 0; k < 3; k++ { + for l := 0; l < 3; l++ { + tot += image[i+k][j+l] + } + } + for k := 0; k < 3; k++ { + for l := 0; l < 3; l++ { + ct[i+k][j+l]++ + ans[i+k][j+l] += tot / 9 + } + } + } + } + } + for i := 0; i < n; i++ { + for j := 0; j < m; j++ { + if ct[i][j] == 0 { + ans[i][j] = image[i][j] + } else { + ans[i][j] /= ct[i][j] + } + } + } + return ans +} +func abs(x int) int { + if x < 0 { + return -x + } + return x +} From 3d1e26ae249d04ed24fac613cbc1a345c36b8ee0 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 18:59:13 +0530 Subject: [PATCH 14/17] feat: add solutions to lc problems: No.3030 --- .../Solution.java | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 solution/3000-3099/3030.Find the Grid of Region Average/Solution.java diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/Solution.java b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.java new file mode 100644 index 0000000000000..038f3fde9de19 --- /dev/null +++ b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.java @@ -0,0 +1,47 @@ +class Solution { + public int[][] resultGrid(int[][] image, int threshold) { + int n = image.length; + int m = image[0].length; + int[][] ans = new int[n][m]; + int[][] ct = new int[n][m]; + for (int i = 0; i + 2 < n; ++i) { + for (int j = 0; j + 2 < m; ++j) { + boolean region = true; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 2; ++l) { + region &= Math.abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (int k = 0; k < 2; ++k) { + for (int l = 0; l < 3; ++l) { + region &= Math.abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + int tot = 0; + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (int k = 0; k < 3; ++k) { + for (int l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += tot / 9; + } + } + } + } + } + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (ct[i][j] == 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] /= ct[i][j]; + } + } + } + return ans; + } +} From 18fe26592bea264d69679b7c7a0736e180498677 Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 19:00:27 +0530 Subject: [PATCH 15/17] feat: add solutions to lc problems: No.3030 --- .../Solution.py | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 solution/3000-3099/3030.Find the Grid of Region Average/Solution.py diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/Solution.py b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.py new file mode 100644 index 0000000000000..456fea5ddf3d8 --- /dev/null +++ b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.py @@ -0,0 +1,33 @@ +class Solution: + def resultGrid(self, image: List[List[int]], threshold: int) -> List[List[int]]: + n, m = len(image), len(image[0]) + ans = [[0] * m for _ in range(n)] + ct = [[0] * m for _ in range(n)] + for i in range(n - 2): + for j in range(m - 2): + region = True + for k in range(3): + for l in range(2): + region &= abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold + for k in range(2): + for l in range(3): + region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold + + if region: + tot = 0 + for k in range(3): + for l in range(3): + tot += image[i + k][j + l] + for k in range(3): + for l in range(3): + ct[i + k][j + l] += 1 + ans[i + k][j + l] += tot // 9 + + for i in range(n): + for j in range(m): + if ct[i][j] == 0: + ans[i][j] = image[i][j] + else: + ans[i][j] //= ct[i][j] + + return ans From 4a743cf5e28a9d05df149b31ac59f5b13c99245d Mon Sep 17 00:00:00 2001 From: Sandarbh Singhal <123533242+Nothing-avil@users.noreply.github.com> Date: Sun, 4 Feb 2024 19:00:55 +0530 Subject: [PATCH 16/17] feat: add solutions to lc problems: No.3030 --- .../Solution.ts | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 solution/3000-3099/3030.Find the Grid of Region Average/Solution.ts diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/Solution.ts b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.ts new file mode 100644 index 0000000000000..c8915d0618f04 --- /dev/null +++ b/solution/3000-3099/3030.Find the Grid of Region Average/Solution.ts @@ -0,0 +1,46 @@ +function resultGrid(image: number[][], threshold: number): number[][] { + const n: number = image.length; + const m: number = image[0].length; + const ans: number[][] = new Array(n).fill(0).map(() => new Array(m).fill(0)); + const ct: number[][] = new Array(n).fill(0).map(() => new Array(m).fill(0)); + for (let i = 0; i + 2 < n; ++i) { + for (let j = 0; j + 2 < m; ++j) { + let region: boolean = true; + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 2; ++l) { + region &&= Math.abs(image[i + k][j + l] - image[i + k][j + l + 1]) <= threshold; + } + } + for (let k = 0; k < 2; ++k) { + for (let l = 0; l < 3; ++l) { + region &&= Math.abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold; + } + } + if (region) { + let tot: number = 0; + + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 3; ++l) { + tot += image[i + k][j + l]; + } + } + for (let k = 0; k < 3; ++k) { + for (let l = 0; l < 3; ++l) { + ct[i + k][j + l]++; + ans[i + k][j + l] += Math.floor(tot / 9); + } + } + } + } + } + for (let i = 0; i < n; ++i) { + for (let j = 0; j < m; ++j) { + if (ct[i][j] === 0) { + ans[i][j] = image[i][j]; + } else { + ans[i][j] = Math.floor(ans[i][j] / ct[i][j]); + } + } + } + return ans; +} From 5e21608c8be1c54115b2145f461103eecdbe1c2b Mon Sep 17 00:00:00 2001 From: Nothing-avil Date: Sun, 4 Feb 2024 13:34:06 +0000 Subject: [PATCH 17/17] style: format code and docs with prettier --- .../3030.Find the Grid of Region Average/README.md | 8 ++++---- .../3030.Find the Grid of Region Average/README_EN.md | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/README.md b/solution/3000-3099/3030.Find the Grid of Region Average/README.md index 0f9c70581e236..780543b2d93b4 100644 --- a/solution/3000-3099/3030.Find the Grid of Region Average/README.md +++ b/solution/3000-3099/3030.Find the Grid of Region Average/README.md @@ -67,7 +67,7 @@ class Solution: n, m = len(image), len(image[0]) ans = [[0] * m for _ in range(n)] ct = [[0] * m for _ in range(n)] - + for i in range(n - 2): for j in range(m - 2): region = True @@ -77,7 +77,7 @@ class Solution: for k in range(2): for l in range(3): region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold - + if region: tot = 0 for k in range(3): @@ -87,14 +87,14 @@ class Solution: for l in range(3): ct[i + k][j + l] += 1 ans[i + k][j + l] += tot // 9 - + for i in range(n): for j in range(m): if ct[i][j] == 0: ans[i][j] = image[i][j] else: ans[i][j] //= ct[i][j] - + return ans ``` diff --git a/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md b/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md index 6bb52279b3b61..5df6793a01e7e 100644 --- a/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md +++ b/solution/3000-3099/3030.Find the Grid of Region Average/README_EN.md @@ -63,7 +63,7 @@ class Solution: n, m = len(image), len(image[0]) ans = [[0] * m for _ in range(n)] ct = [[0] * m for _ in range(n)] - + for i in range(n - 2): for j in range(m - 2): region = True @@ -73,7 +73,7 @@ class Solution: for k in range(2): for l in range(3): region &= abs(image[i + k][j + l] - image[i + k + 1][j + l]) <= threshold - + if region: tot = 0 for k in range(3): @@ -83,14 +83,14 @@ class Solution: for l in range(3): ct[i + k][j + l] += 1 ans[i + k][j + l] += tot // 9 - + for i in range(n): for j in range(m): if ct[i][j] == 0: ans[i][j] = image[i][j] else: ans[i][j] //= ct[i][j] - + return ans ```