Merge pull request #297 from SherryShi0108/master

GeekUniversity · web-flow · commit 8cbdb6ef0716 · 2019-04-25T12:07:08.000+08:00
# 086 week1 week2
diff --git a/Week_01/id_86/LeetCode_083_086.c b/Week_01/id_86/LeetCode_083_086.c
@@ -0,0 +1,24 @@
+//simple C
+
+void MethodFor083_1(struct ListNode* head)
+{
+	if (head == NULL)
+	{
+		return NULL;
+	}
+	struct ListNode *p, *q;
+	p = head;
+	while (p->next)
+	{
+		q = p->next;
+		if (p->val == q->val)
+		{
+			p->next = q->next;
+		}
+		else
+		{
+			p = q;
+		}
+	}
+	return head;
+}
diff --git a/Week_01/id_86/LeetCode_083_086.cs b/Week_01/id_86/LeetCode_083_086.cs
@@ -0,0 +1,41 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AlgorithmTest
+{ 
+    public class LeetCode_083_086
+    {
+        /// <summary>
+        /// 92ms 23.9MB
+        /// </summary>
+        /// <param name="head"></param>
+        /// <returns></returns>
+        public ListNode MethodFor093_1(ListNode head)
+        {
+            if (head == null)
+                return null;
+            if (head.next == null)
+                return head;
+            else
+            {
+                ListNode listNode = head;
+                while (listNode.next != null)
+                {
+                    if (listNode.next.val == listNode.val)
+                    {
+                        listNode.next = listNode.next.next;
+                    }
+                    else
+                    {
+                        listNode = listNode.next;
+                    }
+                }
+            }
+
+            return head;
+        }
+    }
+}
diff --git a/Week_01/id_86/LeetCode_083_086.py b/Week_01/id_86/LeetCode_083_086.py
@@ -0,0 +1,14 @@
+
+class Solution(object):
+    def RemoveDuplicatesfromSortedList(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        cur = head
+        while cur and cur.next:
+            if cur.val == cur.next.val:
+                cur.next = cur.next.next
+            else:
+                cur = cur.next
+        return head
diff --git a/Week_01/id_86/LeetCode_905_086.c b/Week_01/id_86/LeetCode_905_086.c
@@ -0,0 +1,22 @@
+//simple C
+
+int* MethodFor905_1(int* A, int ASize, int* BSize) 
+{
+	int e = 0;
+	int o = ASize - 1;
+	int *B = (int *)malloc(sizeof(int) * ASize);
+
+	for (int i = 0; i < ASize; i++)
+	{
+		if (A[i] % 2 == 0)
+		{
+			B[e++] = A[i];
+		}
+		else
+		{
+			B[o--] = A[i];
+		}
+	}
+	*BSize = ASize;
+	return B;
+}
diff --git a/Week_01/id_86/LeetCode_905_086.cs b/Week_01/id_86/LeetCode_905_086.cs
@@ -0,0 +1,82 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AlgorithmTest
+{
+    /// <summary>
+    /// 905. Sort Array By Parity
+    /// Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.You may return any answer array that satisfies this condition.
+    /// </summary>
+    public class LeetCode_905
+    {
+        /// <summary>
+        /// 思路：第一个检查是否是奇数，如果是的话和最后一个交换，在进行检测是否是奇数，和倒数第二个交换，以此往后，到i=n-flag时截止
+        /// </summary>
+        /// 260 ms 31.9MB
+        /// <param name="A"></param>
+        /// <returns></returns>
+        public int[] MethodFor905_1(int[] A)
+        {
+            int n = A.Length;
+            int temp;
+            int flag = 1;
+
+            for (int i = 0; i < n ; i++)
+            {
+                if (A[i] % 2 == 1)
+                {
+                    temp = A[i];
+                    A[i] = A[n - flag];
+                    A[n - flag] = temp;
+
+                    flag++;
+                    i--;
+                }
+                if (i==n-flag) { break; }
+            }
+            return A;
+        }
+
+        /// <summary>
+        /// 参考
+        /// </summary>
+        /// <param name="A"></param>
+        /// <returns></returns>
+        public int[] MethodFor905_2(int[] A)
+        {
+            int l = 0;
+            int r = A.Length - 1;
+            while (l < r)
+            {
+                while (l < r && A[l] % 2 == 0)
+                {
+                    l++;
+                }
+                while (l < r && A[r] % 2 == 1)
+                {
+                    r--;
+                }
+                if (l < r)
+                {
+                    int temp = A[l];
+                    A[l] = A[r];
+                    A[r] = temp;
+                }
+            }
+            return A;
+        }
+
+        /// <summary>
+        /// 参考
+        /// </summary>
+        /// <param name="A"></param>
+        /// <returns></returns>
+        public int[] MethodFor905_3(int[] A)
+        {
+            return A.Where(x => x % 2 == 0).Concat(A.Where(x => x % 2 != 0)).ToArray();
+        }
+    }
+}
diff --git a/Week_01/id_86/LeetCode_905_086.py b/Week_01/id_86/LeetCode_905_086.py
@@ -0,0 +1,4 @@
+
+class Solution(object):
+    def sortArrayByParity(self, A):
+        return [a for a in A if not a % 2] + [a for a in A if a % 2]
diff --git a/Week_01/id_86/LeetCode_922_086.c b/Week_01/id_86/LeetCode_922_086.c
@@ -0,0 +1,21 @@
+int *MethodFor922_1(int const *A, int ASize, int *BSize)
+{
+	int o = 1;
+	int e = 0;
+	int *ret = (int *)malloc(sizeof(int) * (*BSize = ASize));
+
+	for (int i = 0; i < *BSize; ++i)
+	{
+		if (A[i] % 2 == 0)
+		{
+			ret[e] = A[i];
+			e = e + 2;
+		}
+		else
+		{
+			ret[o] = A[i];
+			o = o + 2;
+		}
+	}
+	return ret;
+}
diff --git a/Week_01/id_86/LeetCode_922_086.cs b/Week_01/id_86/LeetCode_922_086.cs
@@ -0,0 +1,44 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AlgorithmTest
+{
+    /// <summary>
+    /// 922. Sort Array By Parity II
+    /// Given an array A of non-negative integers, half of the integers in A are odd, and half of the integers are even.Sort the array so that whenever A[i] is odd, i is odd; and whenever A[i] is even, i is even.You may return any answer array that satisfies this condition.
+    /// </summary>
+    public class LeetCode_922_086
+    {
+        /// <summary>
+        /// 316ms 35.4MB
+        /// </summary>
+        /// <param name="A"></param>
+        /// <returns></returns>
+        public int[] MethodFor922_1(int[] A)
+        {
+            int n = A.Length;
+            int[] B = new int[n];
+
+            int e = 0;
+            int o = 1;
+            
+            for (int i = 0; i < n; i++)
+            {
+                if (A[i] % 2 == 0)
+                {
+                    B[e] = A[i];
+                    e = e + 2;
+                }
+                else
+                {
+                    B[o] = A[i];
+                    o = o + 2;
+                }
+            }
+            return B;
+        }
+    }
+}
diff --git a/Week_01/id_86/LeetCode_922_086.py b/Week_01/id_86/LeetCode_922_086.py
@@ -0,0 +1,4 @@
+class Solution:
+    def sortArrayByParityII(self, A):
+        e, o = [a for a in A if not a % 2], [a for a in A if a % 2]
+        return [e.pop() if not i % 2 else o.pop() for i in range(len(A))]
diff --git a/Week_02/id_86/LeetCode_242_086.c b/Week_02/id_86/LeetCode_242_086.c
@@ -0,0 +1,30 @@
+#include<stdbool.h> 
+
+// 120ms 7.1MB
+bool MethodFor242_1(char* s, char* t) 
+{
+	int flag = 1;
+	if (strlen(s) != strlen(t))
+	{
+		flag = 0;
+	}
+	else
+	{
+		int a[26] = { 0 };
+		for (int i = 0; i < strlen(s); i++)
+		{
+			a[s[i] - 'a']++;
+			a[t[i] - 'a']--;
+		}
+
+		for (int i = 0; i < 26; i++)
+		{
+			if (a[i] != 0)
+			{
+				flag = 0;
+			}
+		}
+	}
+	return flag;
+
+}
diff --git a/Week_02/id_86/LeetCode_242_086.cs b/Week_02/id_86/LeetCode_242_086.cs
@@ -0,0 +1,57 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AlgorithmTest
+{
+    class LeetCode_242_086
+    {
+        /// <summary>
+        /// 104ms 21.7MB
+        /// </summary>
+        /// <param name="s"></param>
+        /// <param name="t"></param>
+        /// <returns></returns>
+        public bool MethodFor242_1(string s, string t)
+        {
+            if (s.Length != t.Length) return false;
+
+            Dictionary<char, int> d = new Dictionary<char, int>();
+
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (d.ContainsKey(s[i]))
+                {
+                    d[s[i]]++;
+
+                    if (d[s[i]] == 0)
+                    {
+                        d.Remove(s[i]);
+                    }
+                }
+                else
+                {
+                    d.Add(s[i],1);
+                }
+
+                if (d.ContainsKey(t[i]))
+                {
+                    d[t[i]]--;
+
+                    if (d[t[i]]==0)
+                    {
+                        d.Remove(t[i]);
+                    }
+                }
+                else
+                {
+                    d.Add(t[i], -1);
+                }
+            }
+
+            return d.Count==0;
+        }
+    }
+}
diff --git a/Week_02/id_86/LeetCode_242_086.py b/Week_02/id_86/LeetCode_242_086.py
@@ -0,0 +1,12 @@
+class Solution(object):
+    def isAnagram(self, s, t):
+        dic1 = {}
+        dic2 = {}
+        for t in s:
+            dic1[t] = dic1.get(t,0)+1
+        for t in t:
+            dic2[t] = dic2.get(t,0)+1
+        return dic1 == dic2
+
+    def isAnagram2(self, s, t):
+        return sorted(s) == sorted(t)
diff --git a/Week_02/id_86/LeetCode_671_086.cs b/Week_02/id_86/LeetCode_671_086.cs
