golang大厂面试

Golang字节面试经验分享

第一面

面试官首先介绍说会有几轮面试

算法题 1.1
将整数转换二进制 然后将负数变成

例子

例如，n = 1（1:1 的二进制表示）

例如，n = 5（5 的二进制表示：101）

例如，n = 20（5 的二进制表示：10100）

例如，n = 31（31 的二进制表示：11111）

解决这个问题的方法

步骤 1 - 定义一个接受整数n 的方法。

第 2 步-使用golang包将n转换为二进制表示

步骤 3 - 返回转换后的二进制表示。

package main

import (
	"fmt"
	"strconv"
)

func IntegerToBinary(n int) string {
	return strconv.FormatInt(int64(n), 2)
}
func main() {
	n := 1
	fmt.Printf("Binary Representation of %d is %s.\n", n, IntegerToBinary(n))
	n = 5
	fmt.Printf("Binary Representation of %d is %s.\n", n, IntegerToBinary(n))
	n = 20
	fmt.Printf("Binary Representation of %d is %s.\n", n, IntegerToBinary(n))
	n = 31
	fmt.Printf("Binary Representation of %d is %s.\n", n, IntegerToBinary(n))
}

PS D:\Workspace\Go\src\projects\demo> go run main.go
Binary Representation of 1 is 1.
Binary Representation of 5 is 101.   
Binary Representation of 20 is 10100.
Binary Representation of 31 is 11111.

int->bin  的转化

包含了正整数，负整数，0 的转化

package main

import (
	"fmt"
	"strconv"
)

//bin表示转化后的位数
func convertToBin(n int, bin int) string {
	var b string
	switch {
	case n == 0:
		for i := 0; i < bin; i++ {
			b += "0"
		}
	case n > 0:
		//strcov.Itoa 将 1 转为 "1" , string(1)直接转为assic码
		for ; n > 0; n /= 2 {
			b = strconv.Itoa(n%2) + b
		}
		// 加0
		j := bin - len(b)
		for i := 0; i < j; i++ {
			b = "0" + b
		}
	case n < 0:
		n = n * -1
		// fmt.Println("变为正数：",n)
		s := convertToBin(n, bin)
		// fmt.Println("bin:",s)
		//取反
		for i := 0; i < len(s); i++ {
			if s[i:i+1] == "1" {
				b += "0"
			} else {
				b += "1"
			}
		}
		// fmt.Println("~bin :",b)
		//转化为整型，之后加1 这里必须要64，否则在转化过程中可能会超出范围
		n, err := strconv.ParseInt(b, 2, 64)
		if err != nil {
			fmt.Println(err)
		}
		//转为bin
		//+1
		b = convertToBin(int(n+1), bin)
	}

	return b
}
func main() {
	fmt.Println(
		convertToBin(5, 2),  //101
		convertToBin(13, 2), //1101
		convertToBin(11111, 2),
		convertToBin(0, 2),
		convertToBin(1, 2),
		convertToBin(-5, 2),
		convertToBin(-11111, 2),
	)
}

比如-11111的转化：

变为正数： 11111
bin: 10101101100111
~bin : 01010010011000
结果：1010010011001

正数用原码表示，负数用补码表示，补码=反码+1

算法题 1.2

买卖股票的最大利润
给定一个数组代表股票每天的价格，请问买卖多次的情况下，最大化利润是多少？ 日期不重叠的
情况下，可以买卖多次? 输入: {100, 80, 120, 130, 70, 60, 100, 125} 可以买卖多次: 115（80买
进，130卖出；60 买进，125卖出） 提示：不用输出买卖的序列，只需要得到最大利润
时间复杂度是多少
空间复杂度是多少

一次遍历法。
遍历的时候，累加所有的大于0的【prices[i]-prices[i-1]】，这个累加值就是需要返回的值。
时间复杂度：O(N)。空间复杂度：O(1)。

package main

import (
	"fmt"
)

func main() {
	arr := []int{100, 80, 120, 130, 70, 60, 100, 125}
	ret := maxProfit(arr)
	fmt.Println(ret)
}

func maxProfit(prices []int) int {
	N := len(prices)
	if N <= 1 {
		return 0
	}
	ans := 0
	for i := 1; i < N; i++ {
		ans += getMax(prices[i]-prices[i-1], 0)
	}
	return ans
}

func getMax(a int, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

PS D:\Workspace\Go\src\projects\demo> go run main.go
115

如果只交易一次的话：

解题思路：利润最大只需要在股票价格最低点买入，在最高点卖出即可（不考虑买入卖出手续费的情况）

利润=卖出价格（最大值）- 买入价格（最小值）。

代码实现如下：该算法实现时间复杂度为O(n)。

func maxProfitOneDeal(prices []int) (profit int) {
	if len(prices) == 0 {
		return 0
	}
	purchase, sell := prices[0], prices[0] //初始化：purchase：购买，sell：卖出
	for _, price := range prices {
		if price < purchase { // 如果当前股票价格小于买入价格，那么将当前价格赋值给买入价格
			purchase = price
			sell = 0
		} else if price > sell { // 如果当前股票价格大于卖出价格，那么将当前价格赋值给卖出价格
			if sell-purchase > profit {
				profit = sell - purchase // 利润=卖出价格-买入价格
			}
		}
	}
	// fmt.Println("profit", profit)
	return profit
}
func main() {
	arr := []int{100, 80, 120, 130, 70, 60, 100, 125}
	ret := maxProfit(arr)
	fmt.Println(ret)
	ret1 := maxProfitOneDeal(arr)
	fmt.Println(ret1)
	ret2 := maxProfitMultiDeal(arr)
	fmt.Println(ret2)

}

交易多次获得的最大利润：

解题思路：多次交易利润最大，只需要每次都在最低点买入，在下一次的最高点卖出。

利用数学求极值的思想，找出价格数组中的极大值（卖出价格）和极小值（买入价格）。

//for 循环中除去了第一天和最后一天的股票价格，求数组中的极大值和极小值。

极小值点买入，极大值点卖出；最后一天股票价格如果>买入价格，则最后一天卖出（最后面极小值点买入，未出现极大值点，那就是最后一天卖出）。利润最大。（数学中求极值思想）

golang代码实现如下：该算法实现时间复杂度为O(n)。 

//可交易多次，股票交易最大收益
func maxProfitMultiDeal(prices []int) (profit int) {
	if len(prices) == 0 {
		return 0
	}
	buy := prices[0] //买入初始值为第一天的股票价格
	for i := 1; i < len(prices)-1; i++ {
		//如果第i天的股票价格是极小值，赋值给buy，作为买入价格
		if prices[i]-prices[i-1] <= 0 && prices[i]-prices[i+1] <= 0 && prices[i] < buy {
			buy = prices[i]
			// log.Info("buy in第 i天", i)
		} else if prices[i]-prices[i-1] > 0 && prices[i]-prices[i+1] >= 0 && prices[i] > buy { //极大值点卖出
			profit += (prices[i] - buy)
			// log.Info("sell out第 i天", i)
			buy = prices[i+1]
		}
	}
	// log.Info("profit", profit)
	return profit
}

判断题 2.1 这段代码有什么问题，如何解决

func main() {
	total := 0
	sum := 0
	for i := 1; i <= 10; i++ {
		sum += i
		go func() {
			total += i
		}()
	}
	fmt.Printf("total:%d sum %d", total, sum)
}

PS D:\Workspace\Go\src\projects\demo> go run main.go
total:0 sum 55