编写一个程序判断给定的数是否为丑数。

丑数就是只包含质因数 2, 3, 5 的正整数。

示例 1:
输入: 6
输出: true
解释: 6 = 2 × 3
示例 2:
输入: 8
输出: true
解释: 8 = 2 × 2 × 2
示例 3:
输入: 14
输出: false 
解释: 14 不是丑数，因为它包含了另外一个质因数 7。

说明：

1 是丑数。
2 输入不会超过 32 位有符号整数的范围: [−2^31,  2^31 − 1]。

public bool IsUgly(int num) {
    if(num <= 0) return false;
    while(num%2 == 0) num /= 2;
    while(num%3 == 0) num /= 3;
    while(num%5 == 0) num /= 5;

    return num == 1;
}

请判断一个链表是否为回文链表。

示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public bool IsPalindrome(ListNode head) {
        //反转前端链表
        int num = 0;
        ListNode temp = head;
        while(temp != null)
        {
            num++;
            temp = temp.next;
        }
        
        int medioNum = num / 2;
        ListNode preNode = null;
        ListNode curNode = head;
        ListNode startNode = null;
        while(medioNum != 0)//反转前半段链表
        {
            temp = curNode.next;
            curNode.next = preNode;
            preNode = curNode;
            curNode = temp;
            medioNum--;
        }
        //此时，preNode为前半段的头结点，curNode为后半段的头结点
        if(num % 2 == 1)
        {
            //链表为奇数的情况下，中间的结点为公有结点不用检查
            curNode = curNode.next;
        }
        
        while(curNode != null)
        {
            if(curNode.val != preNode.val)
                return false;
            
            curNode = curNode.next;
            preNode = preNode.next;
        }
        
        return true;
        
    }
}

一次过，我都惊呆了，虽然不难。先遍历链表计算链表的长度，反转前半段的链表，然后逐个对比就可以了。

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的绝对值最大为 k。

示例 1:
输入: nums = [1,2,3,1], k = 3
输出: true
示例 2:
输入: nums = [1,0,1,1], k = 1
输出: true
示例 3:
输入: nums = [1,2,3,1,2,3], k = 2
输出: false

public bool ContainsNearbyDuplicate(int[] nums, int k) {
    Dictionary<int,int> dic = new Dictionary<int,int>();
    for(int i = 0;i<nums.Length;i++)
    {
        if(dic.ContainsKey(nums[i]))
        {
            if(Math.Abs(dic[nums[i]] - i) <= k)
            {
                return true;
            }
            else
            {
                dic[nums[i]] = i;//更新下标位置，前面的的无用啦
            }
        }
        else
        {
            dic.Add(nums[i],i);
        }
    }

    return false;
}

反转一个单链表。

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode ReverseList(ListNode head) {
        
        //用三个指标，一个保存上一个，一个保存当前，一个用来临时保存数据
        ListNode temp = head;
        ListNode preNode = null;
        ListNode curNode = head;
        while(curNode != null)
        {
            temp = curNode.next;
            curNode.next = preNode;
            preNode = curNode;
            curNode = temp;
        }
        
        return preNode;
    }
}

删除链表中等于给定值 val 的所有节点。

示例:
输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode RemoveElements(ListNode head, int val) {
        
        ListNode MyHead = new ListNode(0);//建一个头结点，应对要删除first结点的情况，达到一致的普遍性
        MyHead.next = head;
        ListNode preNode = MyHead;
        while(head != null)
        {
            if(head.val == val)
            {
                //移除结点，上一个结点不变
                preNode.next = head.next;
            }
            else
            {
                preNode = head;//上一个结点推进
            }
            head = head.next;//日常推进
        }
        
        return MyHead.next;
    }
}