feat: add solutions to lc problem: No.0953

No.0953.Verifying an Alien Dictionary

Author: YangFong

solution/0900-0999/0953.Verifying an Alien Dictionary/README.md

@@ -165,6 +165,37 @@ func isAlienSorted(words []string, order string) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function isAlienSorted(words: string[], order: string): boolean {
+    const map = new Map();
+    for (const c of order) {
+        map.set(c, map.size);
+    }
+    const n = words.length;
+    for (let i = 1; i < n; i++) {
+        const s1 = words[i - 1];
+        const s2 = words[i];
+        const m = Math.min(s1.length, s2.length);
+        let isEqual = false;
+        for (let j = 0; j < m; j++) {
+            if (map.get(s1[j]) > map.get(s2[j])) {
+                return false;
+            }
+            if (map.get(s1[j]) < map.get(s2[j])) {
+                isEqual = true;
+                break;
+            }
+        }
+        if (!isEqual && s1.length > s2.length) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -198,6 +229,40 @@ impl Solution {
 }
 ```
 
+### **C**
+
+```c
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+
+bool isAlienSorted(char **words, int wordsSize, char *order) {
+    int map[26] = {0};
+    for (int i = 0; i < 26; i++) {
+        map[order[i] - 'a'] = i;
+    }
+    for (int i = 1; i < wordsSize; i++) {
+        char *s1 = words[i - 1];
+        char *s2 = words[i];
+        int n = strlen(s1);
+        int m = strlen(s2);
+        int len = min(n, m);
+        int isEqual = 1;
+        for (int j = 0; j < len; j++) {
+            if (map[s1[j] - 'a'] > map[s2[j] - 'a']) {
+                return 0;
+            }
+            if (map[s1[j] - 'a'] < map[s2[j] - 'a']) {
+                isEqual = 0;
+                break;
+            }
+        }
+        if (isEqual && n > m) {
+            return 0;
+        }
+    }
+    return 1;
+}
+```
+
 ### **...**
 
 ```

solution/0900-0999/0953.Verifying an Alien Dictionary/README_EN.md

@@ -155,6 +155,37 @@ func isAlienSorted(words []string, order string) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function isAlienSorted(words: string[], order: string): boolean {
+    const map = new Map();
+    for (const c of order) {
+        map.set(c, map.size);
+    }
+    const n = words.length;
+    for (let i = 1; i < n; i++) {
+        const s1 = words[i - 1];
+        const s2 = words[i];
+        const m = Math.min(s1.length, s2.length);
+        let isEqual = false;
+        for (let j = 0; j < m; j++) {
+            if (map.get(s1[j]) > map.get(s2[j])) {
+                return false;
+            }
+            if (map.get(s1[j]) < map.get(s2[j])) {
+                isEqual = true;
+                break;
+            }
+        }
+        if (!isEqual && s1.length > s2.length) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -188,6 +219,40 @@ impl Solution {
 }
 ```
 
+### **C**
+
+```c
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+
+bool isAlienSorted(char **words, int wordsSize, char *order) {
+    int map[26] = {0};
+    for (int i = 0; i < 26; i++) {
+        map[order[i] - 'a'] = i;
+    }
+    for (int i = 1; i < wordsSize; i++) {
+        char *s1 = words[i - 1];
+        char *s2 = words[i];
+        int n = strlen(s1);
+        int m = strlen(s2);
+        int len = min(n, m);
+        int isEqual = 1;
+        for (int j = 0; j < len; j++) {
+            if (map[s1[j] - 'a'] > map[s2[j] - 'a']) {
+                return 0;
+            }
+            if (map[s1[j] - 'a'] < map[s2[j] - 'a']) {
+                isEqual = 0;
+                break;
+            }
+        }
+        if (isEqual && n > m) {
+            return 0;
+        }
+    }
+    return 1;
+}
+```
+
 ### **...**
 
 ```

solution/0900-0999/0953.Verifying an Alien Dictionary/Solution.c

@@ -0,0 +1,29 @@
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+
+bool isAlienSorted(char **words, int wordsSize, char *order) {
+    int map[26] = {0};
+    for (int i = 0; i < 26; i++) {
+        map[order[i] - 'a'] = i;
+    }
+    for (int i = 1; i < wordsSize; i++) {
+        char *s1 = words[i - 1];
+        char *s2 = words[i];
+        int n = strlen(s1);
+        int m = strlen(s2);
+        int len = min(n, m);
+        int isEqual = 1;
+        for (int j = 0; j < len; j++) {
+            if (map[s1[j] - 'a'] > map[s2[j] - 'a']) {
+                return 0;
+            }
+            if (map[s1[j] - 'a'] < map[s2[j] - 'a']) {
+                isEqual = 0;
+                break;
+            }
+        }
+        if (isEqual && n > m) {
+            return 0;
+        }
+    }
+    return 1;
+}

solution/0900-0999/0953.Verifying an Alien Dictionary/Solution.ts

@@ -0,0 +1,26 @@
+function isAlienSorted(words: string[], order: string): boolean {
+    const map = new Map();
+    for (const c of order) {
+        map.set(c, map.size);
+    }
+    const n = words.length;
+    for (let i = 1; i < n; i++) {
+        const s1 = words[i - 1];
+        const s2 = words[i];
+        const m = Math.min(s1.length, s2.length);
+        let isEqual = false;
+        for (let j = 0; j < m; j++) {
+            if (map.get(s1[j]) > map.get(s2[j])) {
+                return false;
+            }
+            if (map.get(s1[j]) < map.get(s2[j])) {
+                isEqual = true;
+                break;
+            }
+        }
+        if (!isEqual && s1.length > s2.length) {
+            return false;
+        }
+    }
+    return true;
+}