feat(algorithms): 50.pow(x,n)

Author: guocaoyi

README.md

@@ -26,18 +26,18 @@ LeetCode problems' submissions & top randed with TypeScript.
 
 ## Algorithms
 
-| \# | Title | Topics | Difficulty |
-| :--------------------------------------------------------------------- | :--------------------------------------------- | :----- | :----------------------------------------: |
-| [0001](algorithms/0001.two-sum) | two-sum | String | <span class='dif-tag easy'>Easy</span> |
-| [0003](algorithms/0003.longest-substring-without-repeating-characters) | longest-substring-without-repeating-characters | String | <span class='dif-tag easy'>Easy</span> |
-| [0004](algorithms/0004.median-of-two-sorted-arrays) | median-of-two-sorted-arrays | String | <span class='dif-tag hard'>Hard</span> |
-| [0014](algorithms/0014.longest-common-prefix) | longest-common-prefix | String | <span class='dif-tag easy'>Easy</span> |
-| [0017](algorithms/0017.letter-combinations-of-a-phone-number) | letter-combinations-of-a-phone-number | String | <span class='dif-tag easy'>Easy</span> |
-| [0050](algorithms/0050.powx-n) | powx-n | String | <span class='dif-tag easy'>Easy</span> |
-| [0074](algorithms/0074.search-a-2d-matrix) | search-a-2d-matrix | String | <span class='dif-tag easy'>Easy</span> |
-| [0136](algorithms/0136.single-number) | single-number | String | <span class='dif-tag medium'>Medium</span> |
-| [0169](algorithms/0169.majority-element) | majority-element | String | <span class='dif-tag easy'>Easy</span> |
-| [0202](algorithms/0202.happy-number) | happy-number | String | <span class='dif-tag easy'>Easy</span> |
-| [0240](algorithms/0240.search-a-2d-matrix-ii) | search-a-2d-matrix-ii | String | <span class='dif-tag easy'>Easy</span> |
-| [0344](algorithms/0344.reverse-string) | reverse-string | String | <span class='dif-tag easy'>Easy</span> |
-| [0724](algorithms/0724.find-pivot-index) | find-pivot-inde | String | <span class='dif-tag hard'>Hard</span> |
+| \#  | Title | Topics | Difficulty |
+| :------------------------------------------------------------------------------- | :--------------------------------------------- | :----- | :----------------------------------------: |
+| [0001](algorithms/0001.two-sum/README.md) | two-sum | String | <span class='dif-tag easy'>Easy</span> |
+| [0003](algorithms/0003.longest-substring-without-repeating-characters/README.md) | longest-substring-without-repeating-characters | String | <span class='dif-tag easy'>Easy</span> |
+| [0004](algorithms/0004.median-of-two-sorted-arrays/README.md) | median-of-two-sorted-arrays | String | <span class='dif-tag hard'>Hard</span> |
+| [0014](algorithms/0014.longest-common-prefix/README.md) | longest-common-prefix | String | <span class='dif-tag easy'>Easy</span> |
+| [0017](algorithms/0017.letter-combinations-of-a-phone-number/README.md) | letter-combinations-of-a-phone-number | String | <span class='dif-tag easy'>Easy</span> |
+| [0050](algorithms/0050.powx-n)  | powx-n | String | <span class='dif-tag easy'>Easy</span> |
+| [0074](algorithms/0074.search-a-2d-matrix/README.md) | search-a-2d-matrix | String | <span class='dif-tag easy'>Easy</span> |
+| [0136](algorithms/0136.single-number/README.md) | single-number | String | <span class='dif-tag medium'>Medium</span> |
+| [0169](algorithms/0169.majority-element/README.md) | majority-element | String | <span class='dif-tag easy'>Easy</span> |
+| [0202](algorithms/0202.happy-number/README.md) | happy-number | String | <span class='dif-tag easy'>Easy</span> |
+| [0240](algorithms/0240.search-a-2d-matrix-ii/README.md) | search-a-2d-matrix-ii | String | <span class='dif-tag easy'>Easy</span> |
+| [0344](algorithms/0344.reverse-string/README.md) | reverse-string | String | <span class='dif-tag easy'>Easy</span> |
+| [0724](algorithms/0724.find-pivot-index/README.md) | find-pivot-inde | String | <span class='dif-tag hard'>Hard</span> |

algorithms/0001.two-sum/index.ts

@@ -1,10 +1,10 @@
 /**
- * 两次列表遍历
+ * 嵌套循环遍历
  * 这事最偷懒的办法，快速实现后，再考虑优化方案
  * 使用Array.forEach在性能上会有点损耗(测试用例:61ms到59ms)
- * @time 2019.04.13
+ * @time 2018.9.13
  * @status Accepted
- * @runtime 120ms > 41.06%
+ * @runtime 120ms | 40.065%
  */
 var twoSum = (nums: number[], target: number): number[] => {
  for (let i: number = 0; i < nums.length; i++) {
@@ -18,18 +18,14 @@ var twoSum = (nums: number[], target: number): number[] => {
 
 /**
  * 哈希存储
+ * @time
  * @status Accepted
- * @runtime
- * @memory
+ * @runtime 80 ms | 59.00%
  */
 var twoSum = (nums: number[], target: number): number[] => {
  const map: any = {};
- const length = nums.length;
- // 使用Array.forEach在性能上会有点损耗(测试用例:61ms到59ms)
- for (let i = 0; i < length; i++) {
- map[nums[i]] = i;
- }
- for (let i = 0; i < length; i++) {
+ nums.forEach((i, k) => (map[i] = k));
+ for (let i = 0; i < nums.length; i++) {
  const x = target - nums[i];
  if (x in map && map[x] != i) {
  return [i, map[x]];
@@ -38,26 +34,30 @@ var twoSum = (nums: number[], target: number): number[] => {
 };
 
 /**
- * 一次哈希遍历
+ * 方案二：哈希存储
+ * @time
  * @status Accepted
- * @runtime 52ms < 100%
+ * @runtime 56ms | 100.00%
  */
 var twoSum = (nums: number[], target: number): number[] => {
  const map: any = {};
- const length = nums.length;
+ const length: number = nums.length;
+ for (let i = 0; i < length; i++) {
+ map[nums[i]] = i;
+ }
  for (let i = 0; i < length; i++) {
  const x = target - nums[i];
  if (x in map && map[x] != i) {
- return [map[x], i];
+ return [i, map[x]];
  }
- map[nums[i]] = i;
  }
 };
 
 /**
  * 哈希遍历
- * @top
- * @runtime 52ms < 100%
+ * @time
+ * @status Accepted
+ * @runtime 52ms | 100%
  */
 var twoSum = (nums: number[], target: number): number[] => {
  const map: any = {};

algorithms/0003.longest-substring-without-repeating-characters/index.ts

@@ -1,10 +1,13 @@
 /**
- * 987test case,132ms
+ * @time 2018.10.19
+ * @status Output Limit Exceeded
+ * @input `"unpvlhkldvfzvzwdfhojkyczxydauiioxzlkhvvmqamnakrfrhqefsddqifmqocpnoawlvjcyxpyhifbqxhxpkchuivky"`
  */
-var slution = (s: string): number => {
+var lengthOfLongestSubstring = (s: string): number => {
  let maxSub = "",
  currentSub = "";
- const arr = s.split("");
+
+ const arr: string[] = s.split("");
  arr.forEach((s: string) => {
  if (currentSub.includes(s)) {
  // 存在
@@ -26,17 +29,32 @@ var slution = (s: string): number => {
 };
 
 /**
- * 987test case,184ms
+ *
+ * @time 2018.10.19
+ * @status Accepted
+ * @runtime 116ms | 55.08%
  */
-var slution = (s: string): number => {
- const obj = {
- subStr: "",
- maxLen: 0
- };
- for (let i: number = 0; i < s.length; i++) {
- let strArray: string[] = obj.subStr.split(s[i]);
- obj.subStr = strArray[strArray.length - 1] + s[i];
- obj.maxLen = Math.max(obj.maxLen, obj.subStr.length);
- }
- return obj.maxLen;
+var lengthOfLongestSubstring = (s: string): number => {
+ let maxSub: string = "",
+ currentSub: string = "";
+
+ const arr: string[] = s.split("");
+ arr.forEach((s: string) => {
+ if (currentSub.includes(s)) {
+ // 存在
+ if (currentSub.length >= maxSub.length) {
+ maxSub = currentSub;
+ }
+ let [lStr, rStr] = currentSub.split(s);
+ currentSub = rStr || "";
+ currentSub += s;
+ } else {
+ // 不存在
+ currentSub += s;
+ if (currentSub.length >= maxSub.length) {
+ maxSub = currentSub;
+ }
+ }
+ });
+ return maxSub.length;
 };

algorithms/0004.median-of-two-sorted-arrays/index.ts

@@ -0,0 +1,47 @@
+/**
+ * 递归
+ * @time 2019.1.4
+ * @status Accepted
+ * @runtime 168ms | 19.48%
+ * @memory 15.8MB |
+ */
+var findMedianSortedArrays = (nums1: number[], nums2: number[]): number => {
+ const findKth = (nums1: number[], nums2: number[], k: number): number => {
+ var m: number = nums1.length;
+ var n: number = nums2.length;
+ if (m > n) {
+ return findKth(nums2, nums1, k);
+ }
+ if (m === 0) {
+ return nums2[k - 1];
+ }
+ if (k === 1) {
+ return Math.min(nums1[0], nums2[0]);
+ }
+ var pa = Math.floor(k / 2) < m ? Math.floor(k / 2) : m;
+ var pb = k - pa;
+ if (nums1[pa - 1] < nums2[pb - 1]) {
+ var t1 = nums1.slice(pa);
+ return findKth(t1, nums2, k - pa);
+ } else if (nums1[pa - 1] > nums2[pb - 1]) {
+ var t2 = nums2.slice(pb);
+ //nums2.splice(0,pb);
+ return findKth(nums1, t2, k - pb);
+ } else {
+ return nums1[pa - 1];
+ }
+ };
+
+ var m = nums1.length;
+ var n = nums2.length;
+ var tol = m + n;
+ if (tol / 2 - Math.floor(tol / 2) > 0.1) {
+ return findKth(nums1, nums2, Math.floor(tol / 2) + 1);
+ } else {
+ return (
+ (findKth(nums1, nums2, Math.floor(tol / 2)) +
+ findKth(nums1, nums2, Math.floor(tol / 2) + 1)) /
+ 2
+ );
+ }
+};

algorithms/0014.longest-common-prefix/index.ts

@@ -2,9 +2,8 @@
  * 循环遍历
  * 刚拿到这题没有细想，认为这题比较简单；直接使用循环遍历的方式一遍一遍顺序访问数组。当子字符串不相等时 Break，结果却超时了。简单了分析了原因在长数组的情况下，过多的进行了顺序访问，实践复杂度为 O(k\*n)。便放弃广度优先，改为深读优先。后面发现，是长度为 1 的数组进入了死循环。
  * @status Time Limit Exceeded
- * @params `[""]`
  */
-var longestCommonPrefix = function(strs: string[]) {
+var longestCommonPrefix = (strs: string[]): string => {
  let prefix: string = "";
  if (strs && strs.length > 0) {
  let point = 1;
@@ -28,7 +27,7 @@ var longestCommonPrefix = function(strs: string[]) {
  * @status Time Limit Exceeded
  * @params `["",""]`
  */
-var longestCommonPrefix = function(strs: string[]) {
+var longestCommonPrefix = (strs: string[]): string => {
  let prefix: string = "";
  if (strs.length == 1) {
  return strs[0];
@@ -51,11 +50,12 @@ var longestCommonPrefix = function(strs: string[]) {
 /**
  * 单次遍历
  * 使用 `strs[0]` 作为初始前缀串，逐一遍历 `strs[]` 元素进行比较，如 `String.indexOf !== 0` 则自减长度 1，直至成立后继续访问后面的元素。
+ * @time 2019.03.26
  * @status Accepted
- * @runtime 60ms < 92.74%
- * @memory 33.8MB < 86.74%
+ * @runtime 60ms | 97.88%
+ * @memory 33.8MB | 86.74%
  */
-var longestCommonPrefix = (strs: string[]) => {
+var longestCommonPrefix = (strs: string[]): string => {
  if (strs && strs.length > 0) {
  let prefix: string = strs[0]; // 使用 strs[0] 作为初始前缀串
  for (let i = 1; i < strs.length; i++) {

algorithms/0017.letter-combinations-of-a-phone-number/index.ts

@@ -1,5 +1,7 @@
 /**
  * 笛卡尔积
+ * @time
+ * @status
  */
 var letterCombinations = function(digits: string) {
  // 拨号键盘

algorithms/0050.powx-n/README.md

@@ -29,3 +29,22 @@ Explanation: 2-2 = 1/22 = 1/4 = 0.25
 
 - Math
 - Binary Search
+
+## Submissions
+
+### I: Math.pow
+
+这里偷懒，直接调用了全局对象 Math 静态方法，Math#pow
+
+- Time: 2019.04.19 10:39
+- Status: Acceted
+- Runtime: 76 ms > 42.42%
+- Memory: 34.2 MB < 13.79%
+```typescript
+var myPow = function(x: number, n: number): number | string {
+ return Math.pow(x, n).toFixed(5);
+};
+```
+
+## Top Ranked
+

algorithms/0074.search-a-2d-matrix/index.ts

@@ -1,7 +1,9 @@
 /**
  * 双层遍历
- * @runtime 64ms > 64.69%
- * @memory 35.4MB > 7.41%
+ * @time 2019.3.15
+ * @status Accepted
+ * @runtime 64ms | 58.68%
+ * @memory 35.4MB | 7.41%
  */
 var searchMatrix = (matrix: number[][], target: number): boolean => {
  for (let i = 0; i < matrix.length; i++) {

algorithms/0136.single-number/index.ts

@@ -1,40 +1,22 @@
-/**
- * @runtime 104ms < 58.49%
- * @memory 37.3MB
- */
-var singleNumber = (nums: number[]): any => {
- let map: any = {};
- nums.forEach(n => {
- if (n in map) {
- // map 已经存在 n
- map[n]++;
- } else {
- // 不存在
- map[n] = 1;
- }
- if (map[n] == 2) {
- // 存在并且 == 2
- delete map[n];
- }
- });
- return Object.keys(map);
-};
-
 /**
  * 这里已经没有优化空间了，想想其他方法
- * @runtime 108ms >
- * @memory 36.9mb <
+ * @hash 223496299
+ * @time 2019.04.19
+ * @status Accepted
+ * @runtime 64 ms | 81.78%
+ * @memory 36.9MB | 41.03%
  */
-var singleNumber = (nums: number[]): any => {
+var singleNumber = (nums: number[]): number => {
  let map: any = {};
- nums.forEach((n: number) => {
- if (n in map && map[n] == 1) {
- // 已经存在 且 == 1
- delete map[n];
+ let length: number = nums.length;
+ for (let i: number = 0; i < length; i++) {
+ if (nums[i] in map && map[nums[i]] == 1) {
+ // map 已经存在 n
+ delete map[nums[i]];
  } else {
  // 不存在
- map[n] = 1;
+ map[nums[i]] = 1;
  }
- });
- return Object.keys(map);
+ }
+ return Number(Object.keys(map)[0]);
 };

algorithms/0169.majority-element/index.ts

@@ -2,10 +2,10 @@
  * 通用解法
  * @status Accepted
  * @time 2019.03.01
- * @runtime 68ms > 87.42%
- * @momory 37.2MB < 88.35%
+ * @runtime 68ms | 87.42%
+ * @momory 37.2MB | 88.35%
  */
-var majorityElement = function(nums: number[]) {
+var majorityElement = (nums: number[]): number => {
  let map: any = {};
  nums.forEach(n => {
  if (n in map) {
@@ -15,7 +15,7 @@ var majorityElement = function(nums: number[]) {
  }
  });
  let maximum = 0;
- let maxKey = undefined;
+ let maxKey: any;
 
  for (let k in map) {
  if (map[k] >= maximum) {