[Swift]编码拾遗

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10978800.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

1、寻找重复出现奇数次的数字。

给定一个整形数组，其中只有一个数字出现奇数次，其他数字出现偶数次。找出这个数字？

思考：两个相同的整数异或为零，一个整数和0异或为其本身。异或可以使用交换律和结合律。

例：数组[1,1,2,2,2,3,3,3,3]求出现了奇数次的数字。

1^1^2^2^2^3^3^3^3 

=(1^1)^(2^2)^2^(3^3)^(3^3) 

=0^0^2^0^0

=2

Talk is cheap.Show me your code：

//测试用例
let arr = [1,1,2,2,2,3,3,3,3]
//打印
print(arr.reduce(0,^))
//Print 2

2、不使用额外辅助变量，如何交换两个整型变量x和变量y的值？

思考：异或可以使用交换律和结合律。

x = x ^ y  (​1)
y = x ^ y  (2)
x = x ^ y  (3)

证明：将式1分别代入式2、式3

y = x^y = (x^y)^y = x^(y^y) = x^0 = x
x = x^y = (x^y)^x = (x^x)^y = 0^y = y

Talk is cheap.Show me your code：

func swap(_ x:inout Int,_ y:inout Int)
{
    x = x ^ y
    y = x ^ y
    x = x ^ y
}

测试：

var x:Int = 1
var y:Int = 9
swap(&x,&y)
print(x)
//Print 9
print(y)
//Print 1

3、不使用pow库函数，求m的n次方？

例：求m的7(二进制：111)次方？

可以拆解为：m^7=(m^100)*(m^010)*(m^001)

通过[&1]和[>>1]来逐位读取指数，为1时将该位代表的指数累乘到最终结果中。

Talk is cheap.Show me your code：

func newPow(_ m:Int,_ n:Int) -> Int
{
    var m = m
    var n = n
    var sum:Int = 1
    while(n != 0)
    {
        if n & 1 == 1
        {
            sum *= m
        }
        m *= m
        n = n >> 1
    }
    return sum
}

测试：

print(newPow(3,4))
//print 81

4、取模运算和取余运算的区别

取余运算和取模运算的步骤相同。

对于整数a、b。计算a%b：

(1)、求商： c = a/b;

(2)、计算模或余数： r = a - c*b.

求模运算和求余运算在第一步不同: 

取余运算在取c的值时，向0方向舍入；

取模运算在计算c的值时，向-∞方向舍入。

%在Swift、C、C++，Java 中称为余运算符，在Python中成为的模运算符。

取余运算：Swift、C、C++，Java 

取模运算：Python

Swift是取余运算。若b负值，忽略b的符号。即：a % b = a % (-b)

[总结]

当a和b符号一致时：

取余运算和取模运算所得结果一致。

当a和b符号不一致时：

取余运算结果和a符号一致。

取模运算结果和b符号一致。

测试：

print(6%4)
print(-6%4)
print(6%(-4))
//Print 2
//Print -2
//Print 2

5、数组下标（计数排序）：统计数字、判断字母出现次数。

给定一个整形数组，数组元素的取值范围0~100。

请用O(n)时间复杂度，从小到大打印出来？

思路：把对应的数值作为数组下标，如果这个数出现过，则对应的数组加1。

Talk is cheap.Show me your code： 

func printNum(_ arr:[Int],_ maxNum:Int)
{
    var temp:[Int] = [Int](repeating: 0, count: maxNum + 1)
    for i in 0..<arr.count
    {
        temp[arr[i]] += 1
    }
    for i in 0...maxNum
    {
        for j in 0..<temp[i]
        {
            print("(j):(i)")
        }
    }
}

测试：

let arr:[Int] = [100,5,71,89,66,77,89,91,71,95,5,100]
printNum(arr, 100)
/*
0:5
1:5
0:66
0:71
1:71
0:77
0:89
1:89
0:91
0:95
0:100
1:100
*/

5、递归(n->1)和递推(1->n)

青蛙一次可以跳1级台阶或2级台阶。求该青蛙跳上n级的台阶有多少种跳法？

递归(n->1)法：很多重复计算

func jump(_ n:Int) -> Int
{
    if n <= 2 {return n}
    else
    {
        return jump(n - 1)  +  jump(n - 2)
    }
}

测试：

print(jump(10))
//print 89

备忘录法：巧用数组下标，去除重复计算

当arr[n] = 0时，表示jump(n)未计算，

当arr[n] != 0时，表示jump(n)已计算。

func jump(_ n:Int) -> Int
{
    var arr:[Int] = [Int](repeating: 0, count: 1)
    if n <= 2 {return n}
    else
    {
        //数组自动扩容
        while(n > arr.count - 1)
        {
            arr += [Int](repeating: 0, count: arr.count)
        }
        //未计算
        if arr[n] == 0
        {
            arr[n] = jump(n-1) + jump(n-2)
            return arr[n]
        }
        else
        {
            //已计算
            return arr[n]
        }
    }
}

测试：

print(jump(10))
//print 89
print(jump(11))
//print 144

递推(1->n)法：

func jump(_ n:Int) -> Int
{
    if n <= 2 {return n}
    var n1:Int = 1
    var n2:Int = 2
    var sum:Int = 0
    for _ in 3...n
    {
        sum = n1 + n2
        n1 = n2
        n2 = sum
    }
    return sum
}

测试：

print(jump(10))
//print 89
print(jump(11))
//print 144
print(jump(12))
//print 233

使用递归时常考虑以下问题：

(1). 是否有重复计算，可使用备忘录法来优化。

(2). 是否可采取递推(1->n)的方法，减少递归的开销。