package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

// 请将答题&附上简历，发送至邮箱，谢谢，邮箱
// kongjian@lingjing37.com

//1.        实现一个函数，输入为任意长度的int64数组，返回元素最大差值，例如输入arr=[5,8,10,1,3]，返回9。
func getMaxDiff(arr []int64) int64 {
	min := arr[0]
	max := arr[0]
	for i := 0; i < len(arr); i++ {
		if arr[i] < min {
			min = arr[i]
		}
		if arr[i] > max {
			max = arr[i]
		}
	}
	return max - min
}

//2.        实现一个函数，对输入的扑克牌执行洗牌，保证其是均匀分布的，也就是说列表中的每一张扑克牌出现在列表的每一个位置上的概率必须相同。
func shuffle(oldArray []int64) []int64 {
	rand.Seed(time.Now().Unix())
	n := len(oldArray)
	newArray := make([]int64, n)
	for i := 0; i < n; i++ {
		index := rand.Intn(len(oldArray))
		newArray[i] = oldArray[index]
		oldArray = append(oldArray[:index], oldArray[index+1:]...)
	}
	return newArray
}

//3.        设计一个带失效时间的缓存数据结构，key和value都是string，并实现增删改查接口。
type ExpireMap struct {
	data sync.Map
	n    int64
}

func (e *ExpireMap) Add(key, value string, n int64) {
	e.data.Store(key, value)
	time.AfterFunc(time.Duration(n), func() {
		e.data.Delete(key)
	})
}

func (e *ExpireMap) Delete(key string) {
	e.data.Delete(key)
}

func (e *ExpireMap) Edit(key, value string, n int64) bool {
	_, ok := e.data.Load(key)
	if !ok {
		return false
	}
	e.data.Store(key, value)
	time.AfterFunc(time.Duration(n), func() {
		e.data.Delete(key)
	})
	return true
}

func (e *ExpireMap) Get(key string) (string, bool) {
	valueInterface, ok := e.data.Load(key)
	value, o := valueInterface.(string)
	if !o {
		return "", false
	}
	return value, ok
}

//4.        实现一个游戏算法：输入n和m，代表有n个选手围成一圈（选手编号为0至n-1），0号从1开始报数，报m的选手游戏失败从圆圈中退出，下一个人接着从1开始报数，如此反复，求最后的胜利者编号。
//例如，n=3，m=2，那么失败者编号依次是1、0，最后的胜利者是2号。[1,2,3] [3,1] [3]
//这里考虑m，n都是正常的数据范围，其中：
//1 <= n <= 10^5
//1 <= m <= 10^6
func getVictoryNumber(n, m int64) int64 {
	if n < 1 || n > 100000 || m < 1 || m > 1000000 {
		return -1
	}
	arr := make([]map[int64]int64, n)
	winnerMap := make(map[int64]int64)
	var i int64 = 0
	for ; i < n; i++ {
		arr[i] = map[int64]int64{i: i + 1}
	}
	for {
		if len(arr) > 1 {
			arr = append(arr[m:], arr[:m-1]...)
		} else {
			winnerMap = arr[0]
			break
		}
	}
	var winner int64
	for k := range winnerMap {
		winner = k
	}
	return winner
}

func main() {
	//arr := []int64{5, 8, 10, 1, 3}
	//fmt.Println(getMaxDiff(arr))
	//fmt.Println(getVictoryNumber(3, 2))
	var em ExpireMap
	em.Add("a", "aa", int64(time.Second))
	em.Add("b", "bb", int64(time.Second))
	em.Add("c", "cc", int64(time.Second))
	em.Delete("a")
	em.Edit("b", "dd", int64(time.Second))
	fmt.Println(em.Get("a"))
	fmt.Println(em.Get("b"))
	fmt.Println(em.Get("c"))
}