上周参加一场面试，面试官问了我一道选座位的问题，要从4*4或者3*3的座位中，实现一个函数，输入一个数字n，系统自动匹配n连座的座位，并返回回去

简单的说了下我的思路，面试官意犹未尽，让我花10分钟在黑板上写代码

离开ide的代码能力...基本为零，思索稍后，实在憋不出来

直接说了，写不出来...

回到正题

那到底该怎么实现这个功能呢？

目标

要求：函数输入一个人数，系统自动分配相邻的座位给到用户

比如输入一个数字2，返回黄色方块的两个相邻的位置给到用户

理清需求

1.座位存在两种状态已售出和未售出，已售出的用1标记，未售出的用0标记

2.记录每一行座位的连座的最大容量，因此要增加一列来记录

3.选座位进行时，对座位进行遍历，判断是否符合最大容量要求，比如我输入3，肯定会跳过第二行

代码实现

package main

import (
	"fmt"
	"math"
)

type Seats struct {
	row int
	col int
	s [][]int
	cap int
}

func  New(row, col int) *Seats {
	s := make([][]int, row)
	for i := 0; i < col; i++ {
		s[i] = make([]int, col)
	}
	for i := 0; i < row; i++ {
		for j := 0; j < col; j++ {
			s[i][j] = 1
		}
		s[i] = append(s[i], col)
	}

	return &Seats{row,col,s, col*row}
}


type entry struct {
	x int
	y int
}

func (s *Seats) People(n int) []entry{
	var result []entry
	if n > s.cap {
		return result
	}

	if n <= s.col {
		return s.Search(n)
	}

	if n > s.col {
		snum := math.Floor(float64(n / s.col))
		for i := 0; i < int(snum); i++ {
			result = append(result, s.Search(s.col)...)
		}
		result = append(result, s.Search(n % s.col)...)
	}
	return result
}

func (s *Seats) Search (n int) []entry {
	if n > s.col {
		return []entry{}
	}
	var result []entry
	for i := 0; i < s.row; i++ {
		if s.s[i][len(s.s)] < n {
			continue
		} else {
			for j := 0; j < s.col; j++ {
				if s.s[i][j] == 1 {
					result = append(result, entry{i, j})
					s.s[i][j] = 0
					n--
					s.cap--
					s.s[i][len(s.s)]--
					if n == 0 {
						break
					}
				}
			}
			break
		}

	}
	return result
}

func main()  {
	seats := New(4, 4)
	fmt.Println(seats.s)
	r := seats.People(4)
	w := seats.People(5)

	fmt.Println(seats.s)
	fmt.Println(r)
	fmt.Println(w)
}

代码实现思路

1.返回一个切片是一个entry，包含行号和列号

2.初始化座位的时候，全部都是标记为1

3.选座位（Search）的时候，先与最大容量比对，不符合就进行下一行比对