leetcode

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

 /**
     * 翻转
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_2(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }


    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = temp;
        }
    }


167.两数之和（有序数组）

var twoSum = function(numbers, target) {
    let l = 0; r = numbers.length;
    while(l < r) {
        if (numbers[l] + numbers[r] === target) {
            let res = [l+1, r+1];
            return res;
        } else if (numbers[l] + numbers[r] < target) {
            l ++;
        } else {
            r --;
        }
    }
};

输出列表中去重有序列表

li=[1,2,3,4,5,1,2,3]
new_li=list(set(li))（set之后变成无序）
new_li.sort(key=li.index)
print(new_li)

 

1 li=[1,2,3,4,5,1,2,3]
2 new_li=[]
3 for i in li:
4     if i not in new_li:
5         new_li.append(i)
6 print(new_li)

136. 只出现一次的数字

a = nums[0](利用异或)(

1. 任何数于0异或为任何数 0 ^ n => n

2. 相同的数异或为0: n ^ n => 0

)
for num in range(1:len(nums)):
　　a = a ^ num
return a

杨辉三角 

def generate(self, numRows):
        """
        :type numRows: int
        :rtype: List[List[int]]
        """
        result = []
        for i in range(numRows):
            now = [1]*(i+1)
            if i >= 2:
                for n in range(1,i):
                    now[n] = pre[n-1]+pre[n]
            result += [now]
            pre = now
        return result

numpy中nonzero()返回非零元素的目录。返回值为元组， 两个值分别为两个维度， 包含了相应维度上非零元素的目录值。

numpy中mat()函数与array()函数生成矩阵

杨辉三角：第n行m列元素通项公式为：C(n-1,m-1)=(n-1)!/[(m-1)!(n-m)!]

 

 

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int minPrice = prices[0];
        int maxEarn = 0;
        for (int i = 0; i < prices.length; i++) {
            maxEarn = Math.max(maxEarn, prices[i] - minPrice);
            minPrice = Math.min(minPrice, prices[i]);
        }
        return maxEarn;
    }

204. 计数质数

厄拉多赛筛法(sieve of Eratosthenes)

想要得到一个不大于N的数所有素数，可以先找到不超过根号N的所有素数，设2 = p₁ < p₂ < ......<p_k ≤√N，然后在2,3,4......N里面进行下面的操作：

    留下p₁ = 2，把p₁的倍数全部划掉，

    再留下p₂ ，把p₂ 的倍数全部划掉，

    继续这一过程，直到留下p_k，把p_k的倍数全部划掉，

    最后留下来就是不超过N的全体素数。

def eladuosai(n):
    l = list(range(1,n+1))
    l[0] = 0
    for i in range(2,n+1):
        if l[i-1] != 0 :
            for j in range(i*2,n+1,i):
                l[j-1] = 0
    result = [x for x in l if x != 0]
    return result

求一个等比数组中缺少哪个数可以用求和 再求差
或者使用异或

数字根（Digital Root）就是把一个自然数的各位数字相加，再将所得数的各位数字相加，直到所得数为一位数字为止。而这个一位数便是原来数字的数字根

复数还拥有 conjugate 方法，调用它可以返回该复数的共轭复数对象。

复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数）

 

寻找最后一位1的方法n = n&(~(n-1))

寻找第一位1的方法n = n&(n-1)

 

python 字典初始化为相同的值

li=[i for i in range(26)]
dic=dict.fromkeys(li,0)

反转字典中key值与value值

n={v:k for k,v in dic.items()}

 

371. 两整数之和

异或^这里可看做是相加但是不显现进位,

相与&为了让进位显现出来 <<1左移一位是为了让进位加到对应位置。如果前两步结果相与仍然有进位，则循环，一直到

carry = (a & b) << 1==0

283.移动零
一个数组中选择某些特定的元素放到前面，可以使用双指针法利用下标的变化进行操作

303. 区域和检索 - 数组不可变

若会出现多次使用已计算过的值，则可以考虑使用数组保存已计算值

 

 

405数字转十六进制

核心思想，使用位运算，每4位，对应1位16进制数字。

• 使用0xf(00...01111b)获取num的低4位。
• >>算数位移，其中正数右移左边补0，负数右移左边补1。
• 位移运算并不能保证num==0，需要使用32位int保证（对应16进制小于等于8位）。

使用string直接进行字符串拼接....

def toHex(self, num):
"""
:type num: int
:rtype: str
"""
if num==0:
return '0'
ans=""
he="0123456789abcdef"
while num and len(ans)<8:
ans=he[num & 0xf]+ans
num=num>>4
return ans