心得：

這題要比較兩個字串是否具有相同字母(不管順序)，因為這題比較簡單，所以就嘗試用了許多方式解答。

問題：

Given two strings s and t, write a function to determine if t is an anagram of s.

For example,
s = “anagram”, t = “nagaram”, return true.
s = “rat”, t = “car”, return false.

Note:
You may assume the string contains only lowercase alphabets.

答案：

• LinQ – OrderBy

  public class Solution {
      public bool IsAnagram(string s, string t) {
          return new string(s.OrderBy(x => x).ToArray()) == new string(t.OrderBy(x => x).ToArray());
      }
  }

• LinQ – Sort

  public class Solution {
      public bool IsAnagram(string s, string t) {
          var arr_1 = s.ToList();
          var arr_2 = t.ToList();
          arr_1.Sort();
          arr_2.Sort();
          return new string(arr_1.ToArray()) == new string(arr_2.ToArray());
      }
  }

• Normal – Array.Sort

  public class Solution {
      public bool IsAnagram(string s, string t) {
          var arr_1 = s.ToArray();
          var arr_2 = t.ToArray();
          Array.Sort(arr_1);
          Array.Sort(arr_2);
          return new string(arr_1) == new string(arr_2);
      }
  }

• Normal – 硬幹 (會 Time Limit Exceeded)

  public class Solution {
      public bool IsAnagram(string s, string t) {
          return Sort(s) == Sort(t);
      }
      
      private string Sort(string str){
          string result = "";
           for(int i = 0; i < 25; i++){
              char c = Convert.ToChar(Convert.ToInt16('a') + i);
              for(int j = 0; j < str.Length; j++){
                  if(c == str[j]){
                      result += c;
                  }
              }
          }
          
          return result;
      }
  }

參考：

1. (C#)用迴圈印出字母A到Z

心得：

題目大意是有一陣列1~N且亂序，必須找出N並找出未出現哪些數字，剛開始我用硬幹的方式，結果顯示Time Out如下：

public class Solution {
    public IList<int> FindDisappearedNumbers(int[] nums) {
        List<int> ans = new List<int>();
        
        if(nums.Length > 1){
            //Sort
            for(int i = 0; i < nums.Length; i++){
                for(int j = i; j < nums.Length; j++){
                    if(nums[j] < nums[i]){
                        int tmp = nums[j];
                        nums[j] = nums[i];
                        nums[i] = tmp;
                    }
                }
            }
            
            int n = nums.Length;
            for(int i = 0; i < n; i++){
                bool b = false;
                for(int j = 0; j < nums.Length; j++){
                    if(i+1 == nums[j]){
                        b = true;
                        break;
                    }
                }
                
                if(!b){
                    ans.Add(i+1);
                }
            }
        }else if(nums.Length == 1){
            if(nums[0] != 1){
                ans.Add(1);
            }
        }
        
        return ans;
    }
}

後來改用稍為聰明一點的LinQ來找出N，結果還是Time Out如下：

public class Solution {
    public IList<int> FindDisappearedNumbers(int[] nums) {
        List<int> ans = new List<int>();
        if(nums.Length > 0){
            int max = nums.Max();
            if(max < nums.Length){
                max = nums.Length;
            }
            for(int i = 1; i <= max; i++){
                if(nums.Any(x=> x == i) == false){
                    ans.Add(i);
                }
            }
        }
        
        return ans;
    }
}

最後生氣了，直接全部都用LinQ，交給Range與Except直接省略兩個迴圈並且順利解決！

問題：

Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.

Find all the elements of [1, n] inclusive that do not appear in this array.

Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

答案：

public class Solution {
    public IList<int> FindDisappearedNumbers(int[] nums) {
        List<int> ans = new List<int>();
        
        if(nums.Length > 0){
            ans.AddRange(Enumerable
            .Range(1, nums.Length > nums.Max() ? nums.Length : nums.Max())
            .Except(nums));
        }
        
        return ans;
    }
}

參考：

1. [C#] 對List<T>取交集、聯集及差集