395 lines
6.7 KiB
Go
395 lines
6.7 KiB
Go
package GoUtil
|
||
|
||
import (
|
||
"fmt"
|
||
"math/rand"
|
||
"reflect"
|
||
"server/game/mod/item"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
)
|
||
|
||
func IntSlice(d interface{}) []int {
|
||
if d == nil {
|
||
return nil
|
||
}
|
||
|
||
// Type assertion with safety check
|
||
result, ok := d.([]int)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
return result
|
||
}
|
||
func IntToInt32(d []int) []int32 {
|
||
r := make([]int32, 0, len(d))
|
||
for _, d := range d {
|
||
r = append(r, int32(d))
|
||
}
|
||
return r
|
||
}
|
||
|
||
func Int32ToInt(d []int32) []int {
|
||
r := make([]int, 0, len(d))
|
||
for _, d := range d {
|
||
r = append(r, int(d))
|
||
}
|
||
return r
|
||
}
|
||
|
||
func StringToInt(d []string) []int {
|
||
r := make([]int, 0, len(d))
|
||
for _, d := range d {
|
||
n, _ := strconv.Atoi(d)
|
||
r = append(r, n)
|
||
}
|
||
return r
|
||
}
|
||
|
||
func RandPopSlice(slice []int) ([]int, int) {
|
||
slen := len(slice)
|
||
if slen == 0 {
|
||
return slice, -1
|
||
}
|
||
Id := rand.Intn(slen)
|
||
Val := slice[Id]
|
||
Slice2 := append(slice[0:Id], slice[Id+1:]...)
|
||
return Slice2, Val
|
||
}
|
||
|
||
func RandSlice(slice []int) int {
|
||
slen := len(slice)
|
||
if slen == 0 {
|
||
return 0
|
||
}
|
||
Id := rand.Intn(slen)
|
||
return slice[Id]
|
||
}
|
||
|
||
func RandItem(slice []*item.Item) *item.Item {
|
||
slen := len(slice)
|
||
if slen == 0 {
|
||
return nil
|
||
}
|
||
Id := rand.Intn(slen)
|
||
return slice[Id]
|
||
}
|
||
|
||
func RandSliceNum(s []int, num int) []int {
|
||
if num <= 0 || len(s) == 0 {
|
||
return nil
|
||
}
|
||
if len(s) <= num {
|
||
result := make([]int, len(s))
|
||
copy(result, s)
|
||
return result
|
||
}
|
||
|
||
slice := make([]int, len(s))
|
||
copy(slice, s)
|
||
r := make([]int, 0, num)
|
||
|
||
for i := 0; i < num; i++ {
|
||
Id := rand.Intn(len(slice))
|
||
r = append(r, slice[Id])
|
||
slice = append(slice[0:Id], slice[Id+1:]...)
|
||
}
|
||
return r
|
||
}
|
||
|
||
func RandSliceNum2(s []interface{}, num int) []interface{} {
|
||
if num <= 0 || len(s) == 0 {
|
||
return nil
|
||
}
|
||
if len(s) <= num {
|
||
result := make([]interface{}, len(s))
|
||
copy(result, s)
|
||
return result
|
||
}
|
||
|
||
slice := make([]interface{}, len(s))
|
||
copy(slice, s)
|
||
r := make([]interface{}, 0, num)
|
||
|
||
for i := 0; i < num; i++ {
|
||
Id := rand.Intn(len(slice))
|
||
r = append(r, slice[Id])
|
||
slice = append(slice[0:Id], slice[Id+1:]...)
|
||
}
|
||
return r
|
||
}
|
||
|
||
func RandSliceNumNonAdjacent(s []int, num int) []int {
|
||
slice := make([]int, len(s))
|
||
copy(slice, s)
|
||
if len(slice) < 2*num {
|
||
return nil
|
||
}
|
||
sort.Ints(slice)
|
||
result := make([]int, 0, num)
|
||
for len(result) < num {
|
||
Id := rand.Intn(len(slice))
|
||
result = append(result, slice[Id])
|
||
slice = SubAdjacentElemSlice(slice, Id)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func SubAdjacentElemSlice(s []int, Id int) []int {
|
||
r := make([]int, 0)
|
||
for k, v := range s {
|
||
if k < Id-1 || k > Id+1 {
|
||
r = append(r, v)
|
||
}
|
||
}
|
||
return r
|
||
}
|
||
|
||
func RandStringSlice(slice []string) string {
|
||
slen := len(slice)
|
||
if slen == 0 {
|
||
return ""
|
||
}
|
||
Id := rand.Intn(slen)
|
||
return slice[Id]
|
||
}
|
||
|
||
func SliceStringToInt(s []string) []int {
|
||
if len(s) == 0 {
|
||
return nil
|
||
}
|
||
r := make([]int, 0, len(s))
|
||
for _, v := range s {
|
||
v = strings.Trim(v, " ")
|
||
v1, _ := strconv.Atoi(v)
|
||
r = append(r, v1)
|
||
}
|
||
return r
|
||
}
|
||
|
||
func SliceIntToInt32(s []int) []int32 {
|
||
r := make([]int32, 0, len(s))
|
||
for _, v := range s {
|
||
r = append(r, int32(v))
|
||
}
|
||
return r
|
||
}
|
||
|
||
func PopElemSlice(s []int, Id int) ([]int, bool) {
|
||
for k, v := range s {
|
||
if v == Id {
|
||
return append(s[0:k], s[k+1:]...), true
|
||
}
|
||
}
|
||
return s, false
|
||
}
|
||
|
||
func PopStringElemSlice(s0 []string, Id string) ([]string, bool) {
|
||
s := make([]string, len(s0))
|
||
copy(s, s0)
|
||
for k, v := range s {
|
||
if v == Id {
|
||
return append(s[0:k], s[k+1:]...), true
|
||
}
|
||
}
|
||
return s, false
|
||
}
|
||
|
||
func ElemInSlice(s []int, Id int) bool {
|
||
for _, v := range s {
|
||
if v == Id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func GetElemNum(s []int, Id int) int {
|
||
n := 0
|
||
for _, v := range s {
|
||
if v == Id {
|
||
n++
|
||
}
|
||
}
|
||
return n
|
||
}
|
||
|
||
func InArray(Id int, s []int) bool {
|
||
for _, v := range s {
|
||
if v == Id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func InArray64(Id int64, s []int64) bool {
|
||
for _, v := range s {
|
||
if v == Id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func InStringArray(Id string, s []string) bool {
|
||
for _, v := range s {
|
||
if v == Id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// toInterfaceSlice converts a slice of strings to a slice of empty interfaces
|
||
func ToInterfaceSlice(slice []string) []interface{} {
|
||
result := make([]interface{}, len(slice))
|
||
for i, v := range slice {
|
||
result[i] = v
|
||
}
|
||
return result
|
||
}
|
||
|
||
// a - b
|
||
func SubSlices(a, b []int) []int {
|
||
result := make([]int, 0, len(a))
|
||
for _, num := range a {
|
||
if !InArray(num, b) {
|
||
result = append(result, num)
|
||
}
|
||
}
|
||
return result
|
||
}
|
||
|
||
func PopSlice(s []int) (int, []int) {
|
||
if len(s) == 0 {
|
||
return -1, s
|
||
}
|
||
return s[0], s[1:]
|
||
}
|
||
|
||
// 判断两个切片的元素是否一致
|
||
func SliceEqual(a, b []int) bool {
|
||
if len(a) != len(b) {
|
||
return false
|
||
}
|
||
|
||
// 创建副本以避免修改原始切片
|
||
aCopy := make([]int, len(a))
|
||
bCopy := make([]int, len(b))
|
||
copy(aCopy, a)
|
||
copy(bCopy, b)
|
||
|
||
// 对切片进行排序
|
||
sort.Ints(aCopy)
|
||
sort.Ints(bCopy)
|
||
|
||
// 比较排序后的切片
|
||
return reflect.DeepEqual(aCopy, bCopy)
|
||
}
|
||
|
||
func SlicesEqualString(a, b []string) bool {
|
||
if len(a) != len(b) {
|
||
return false
|
||
}
|
||
|
||
// 创建副本以避免修改原始切片
|
||
aCopy := make([]string, len(a))
|
||
bCopy := make([]string, len(b))
|
||
copy(aCopy, a)
|
||
copy(bCopy, b)
|
||
|
||
// 对切片进行排序
|
||
sort.Strings(aCopy)
|
||
sort.Strings(bCopy)
|
||
|
||
// 比较排序后的切片
|
||
return reflect.DeepEqual(aCopy, bCopy)
|
||
}
|
||
|
||
// IsContainSlice checks if all elements of s2 are contained in s.
|
||
// 注意：此函数会考虑重复元素，s2中的每个元素在s中必须有对应数量
|
||
func IsContainSlice(s []int, s2 []int) bool {
|
||
if len(s2) == 0 {
|
||
return true
|
||
}
|
||
if len(s) < len(s2) {
|
||
return false
|
||
}
|
||
for _, v := range s2 {
|
||
if !InArray(v, s) {
|
||
return false
|
||
}
|
||
s = SubSlices(s, []int{v})
|
||
}
|
||
return true
|
||
}
|
||
|
||
func InitNumSlice(start, end int) []int {
|
||
result := make([]int, 0, end-start+1)
|
||
for i := start; i <= end; i++ {
|
||
result = append(result, i)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func IntSliceToString(slice []int) string {
|
||
str := fmt.Sprintf("%v", slice)
|
||
str = strings.Trim(str, "[]")
|
||
return str
|
||
}
|
||
|
||
func PopStringArray(s []string) (string, []string) {
|
||
if len(s) == 0 {
|
||
return "", s
|
||
}
|
||
return s[0], s[1:]
|
||
}
|
||
|
||
func ShuffleStringArray(s []string) []string {
|
||
r := make([]string, len(s))
|
||
perm := rand.Perm(len(s))
|
||
for i, v := range perm {
|
||
r[v] = s[i]
|
||
}
|
||
return r
|
||
}
|
||
|
||
func ShuffleArray(s []int) []int {
|
||
r := make([]int, len(s))
|
||
perm := rand.Perm(len(s))
|
||
for i, v := range perm {
|
||
r[v] = s[i]
|
||
}
|
||
return r
|
||
}
|
||
|
||
// IsContain 与 IsContainSlice 功能相同，建议使用 IsContainSlice
|
||
func IsContain(s []int, s2 []int) bool {
|
||
if len(s2) == 0 {
|
||
return true
|
||
}
|
||
if len(s) < len(s2) {
|
||
return false
|
||
}
|
||
for _, v := range s2 {
|
||
if !InArray(v, s) {
|
||
return false
|
||
}
|
||
s = SubSlices(s, []int{v})
|
||
}
|
||
return true
|
||
}
|
||
|
||
func IsSameElem(s []int) bool {
|
||
r := make(map[int]struct{})
|
||
for _, v := range s {
|
||
if _, ok := r[v]; ok {
|
||
return true
|
||
}
|
||
r[v] = struct{}{}
|
||
}
|
||
return false
|
||
}
|