Skip to content

Commit f82cd38

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0242
No.0242.Valid Anagram
1 parent 547a7b4 commit f82cd38

File tree

5 files changed

+225
-55
lines changed

5 files changed

+225
-55
lines changed

‎solution/0200-0299/0242.Valid Anagram/README.md

Lines changed: 95 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -87,21 +87,6 @@ class Solution {
8787
}
8888
```
8989

90-
### **TypeScript**
91-
92-
```ts
93-
function isAnagram(s: string, t: string): boolean {
94-
if (s.length != t.length) return false;
95-
let record = new Array(26).fill(0);
96-
let base = 'a'.charCodeAt(0);
97-
for (let i = 0; i < s.length; ++i) {
98-
++record[s.charCodeAt(i) - base];
99-
--record[t.charCodeAt(i) - base];
100-
}
101-
return record.every(v => v == 0);
102-
}
103-
```
104-
10590
### **C++**
10691

10792
```cpp
@@ -165,23 +150,112 @@ var isAnagram = function (s, t) {
165150
};
166151
```
167152

153+
### **TypeScript**
154+
155+
```ts
156+
function isAnagram(s: string, t: string): boolean {
157+
const n = s.length;
158+
const m = t.length;
159+
return n === m && [...s].sort().join('') === [...t].sort().join('');
160+
}
161+
```
162+
163+
```ts
164+
function isAnagram(s: string, t: string): boolean {
165+
const n = s.length;
166+
const m = t.length;
167+
if (n !== m) {
168+
return false;
169+
}
170+
const count = new Array(26).fill(0);
171+
for (let i = 0; i < n; i++) {
172+
count[s.charCodeAt(i) - 'a'.charCodeAt(0)]++;
173+
count[t.charCodeAt(i) - 'a'.charCodeAt(0)]--;
174+
}
175+
return count.every(v => v === 0);
176+
}
177+
```
178+
168179
### **Rust**
169180

170181
```rust
171182
impl Solution {
172183
pub fn is_anagram(s: String, t: String) -> bool {
173-
if s.len() != t.len() {
184+
let n = s.len();
185+
let m = t.len();
186+
if n != m {
174187
return false;
175188
}
176-
let (s, t) = (s.as_bytes(), t.as_bytes());
177-
let mut record = [0; 26];
189+
let mut s = s.chars().collect::<Vec<char>>();
190+
let mut t = t.chars().collect::<Vec<char>>();
191+
s.sort();
192+
t.sort();
193+
for i in 0..n {
194+
if s[i] != t[i] {
195+
return false;
196+
}
197+
}
198+
true
199+
}
200+
}
201+
```
202+
203+
```rust
204+
impl Solution {
205+
pub fn is_anagram(s: String, t: String) -> bool {
178206
let n = s.len();
207+
let m = t.len();
208+
if n != m {
209+
return false;
210+
}
211+
let (s, t) = (s.as_bytes(), t.as_bytes());
212+
let mut count = [0; 26];
179213
for i in 0..n {
180-
record[(s[i] - b'a') as usize] += 1;
181-
record[(t[i] - b'a') as usize] -= 1;
214+
count[(s[i] - b'a') as usize] += 1;
215+
count[(t[i] - b'a') as usize] -= 1;
216+
}
217+
count.iter().all(|&c| c == 0)
218+
}
219+
}
220+
```
221+
222+
### **C**
223+
224+
```c
225+
int cmp(const void *a, const void *b) {
226+
return *(char *) a - *(char *) b;
227+
}
228+
229+
bool isAnagram(char *s, char *t) {
230+
int n = strlen(s);
231+
int m = strlen(t);
232+
if (n != m) {
233+
return 0;
234+
}
235+
qsort(s, n, sizeof(char), cmp);
236+
qsort(t, n, sizeof(char), cmp);
237+
return !strcmp(s, t);
238+
}
239+
```
240+
241+
```c
242+
bool isAnagram(char *s, char *t) {
243+
int n = strlen(s);
244+
int m = strlen(t);
245+
if (n != m) {
246+
return 0;
247+
}
248+
int count[26] = {0};
249+
for (int i = 0; i < n; i++) {
250+
count[s[i] - 'a']++;
251+
count[t[i] - 'a']--;
252+
}
253+
for (int i = 0; i < 26; i++) {
254+
if (count[i]) {
255+
return 0;
182256
}
183-
record.iter().all(|&c| c == 0)
184257
}
258+
return 1;
185259
}
186260
```
187261

‎solution/0200-0299/0242.Valid Anagram/README_EN.md

Lines changed: 95 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -68,21 +68,6 @@ class Solution {
6868
}
6969
```
7070

71-
### **TypeScript**
72-
73-
```ts
74-
function isAnagram(s: string, t: string): boolean {
75-
if (s.length != t.length) return false;
76-
let record = new Array(26).fill(0);
77-
let base = 'a'.charCodeAt(0);
78-
for (let i = 0; i < s.length; ++i) {
79-
++record[s.charCodeAt(i) - base];
80-
--record[t.charCodeAt(i) - base];
81-
}
82-
return record.every(v => v == 0);
83-
}
84-
```
85-
8671
### **C++**
8772

8873
```cpp
@@ -146,23 +131,112 @@ var isAnagram = function (s, t) {
146131
};
147132
```
148133

134+
### **TypeScript**
135+
136+
```ts
137+
function isAnagram(s: string, t: string): boolean {
138+
const n = s.length;
139+
const m = t.length;
140+
return n === m && [...s].sort().join('') === [...t].sort().join('');
141+
}
142+
```
143+
144+
```ts
145+
function isAnagram(s: string, t: string): boolean {
146+
const n = s.length;
147+
const m = t.length;
148+
if (n !== m) {
149+
return false;
150+
}
151+
const count = new Array(26).fill(0);
152+
for (let i = 0; i < n; i++) {
153+
count[s.charCodeAt(i) - 'a'.charCodeAt(0)]++;
154+
count[t.charCodeAt(i) - 'a'.charCodeAt(0)]--;
155+
}
156+
return count.every(v => v === 0);
157+
}
158+
```
159+
149160
### **Rust**
150161

151162
```rust
152163
impl Solution {
153164
pub fn is_anagram(s: String, t: String) -> bool {
154-
if s.len() != t.len() {
165+
let n = s.len();
166+
let m = t.len();
167+
if n != m {
155168
return false;
156169
}
157-
let (s, t) = (s.as_bytes(), t.as_bytes());
158-
let mut record = [0; 26];
170+
let mut s = s.chars().collect::<Vec<char>>();
171+
let mut t = t.chars().collect::<Vec<char>>();
172+
s.sort();
173+
t.sort();
174+
for i in 0..n {
175+
if s[i] != t[i] {
176+
return false;
177+
}
178+
}
179+
true
180+
}
181+
}
182+
```
183+
184+
```rust
185+
impl Solution {
186+
pub fn is_anagram(s: String, t: String) -> bool {
159187
let n = s.len();
188+
let m = t.len();
189+
if n != m {
190+
return false;
191+
}
192+
let (s, t) = (s.as_bytes(), t.as_bytes());
193+
let mut count = [0; 26];
160194
for i in 0..n {
161-
record[(s[i] - b'a') as usize] += 1;
162-
record[(t[i] - b'a') as usize] -= 1;
195+
count[(s[i] - b'a') as usize] += 1;
196+
count[(t[i] - b'a') as usize] -= 1;
197+
}
198+
count.iter().all(|&c| c == 0)
199+
}
200+
}
201+
```
202+
203+
### **C**
204+
205+
```c
206+
int cmp(const void *a, const void *b) {
207+
return *(char *) a - *(char *) b;
208+
}
209+
210+
bool isAnagram(char *s, char *t) {
211+
int n = strlen(s);
212+
int m = strlen(t);
213+
if (n != m) {
214+
return 0;
215+
}
216+
qsort(s, n, sizeof(char), cmp);
217+
qsort(t, n, sizeof(char), cmp);
218+
return !strcmp(s, t);
219+
}
220+
```
221+
222+
```c
223+
bool isAnagram(char *s, char *t) {
224+
int n = strlen(s);
225+
int m = strlen(t);
226+
if (n != m) {
227+
return 0;
228+
}
229+
int count[26] = {0};
230+
for (int i = 0; i < n; i++) {
231+
count[s[i] - 'a']++;
232+
count[t[i] - 'a']--;
233+
}
234+
for (int i = 0; i < 26; i++) {
235+
if (count[i]) {
236+
return 0;
163237
}
164-
record.iter().all(|&c| c == 0)
165238
}
239+
return 1;
166240
}
167241
```
168242

‎solution/0200-0299/0242.Valid Anagram/Solution.c

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
bool isAnagram(char *s, char *t) {
2+
int n = strlen(s);
3+
int m = strlen(t);
4+
if (n != m) {
5+
return 0;
6+
}
7+
int count[26] = {0};
8+
for (int i = 0; i < n; i++) {
9+
count[s[i] - 'a']++;
10+
count[t[i] - 'a']--;
11+
}
12+
for (int i = 0; i < 26; i++) {
13+
if (count[i]) {
14+
return 0;
15+
}
16+
}
17+
return 1;
18+
}

‎solution/0200-0299/0242.Valid Anagram/Solution.rs

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,16 @@
11
impl Solution {
22
pub fn is_anagram(s: String, t: String) -> bool {
3-
if s.len() != t.len() {
3+
let n = s.len();
4+
let m = t.len();
5+
if n != m {
46
return false;
57
}
68
let (s, t) = (s.as_bytes(), t.as_bytes());
7-
let mut record = [0; 26];
8-
let n = s.len();
9+
let mut count = [0; 26];
910
for i in 0..n {
10-
record[(s[i] - b'a') as usize] += 1;
11-
record[(t[i] - b'a') as usize] -= 1;
11+
count[(s[i] - b'a') as usize] += 1;
12+
count[(t[i] - b'a') as usize] -= 1;
1213
}
13-
record.iter().all(|&c| c == 0)
14+
count.iter().all(|&c| c == 0)
1415
}
1516
}

‎solution/0200-0299/0242.Valid Anagram/Solution.ts

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,13 @@
11
function isAnagram(s: string, t: string): boolean {
2-
if (s.length != t.length) return false;
3-
let record = new Array(26).fill(0);
4-
let base = 'a'.charCodeAt(0);
5-
for (let i = 0; i < s.length; ++i) {
6-
++record[s.charCodeAt(i) - base];
7-
--record[t.charCodeAt(i) - base];
2+
const n = s.length;
3+
const m = t.length;
4+
if (n !== m) {
5+
return false;
86
}
9-
return record.every(v => v == 0);
7+
const count = new Array(26).fill(0);
8+
for (let i = 0; i < n; i++) {
9+
count[s.charCodeAt(i) - 'a'.charCodeAt(0)]++;
10+
count[t.charCodeAt(i) - 'a'.charCodeAt(0)]--;
11+
}
12+
return count.every(v => v === 0);
1013
}

0 commit comments

Comments
 (0)