数据结构乱序比对指定值正确性

取题目选项多个；题目答案多个比对

package main

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

type Pro struct {
	Name    string   `json:"name"`
	Options []string `json:"options"`
	Answers []int    `json:"answers"`
}

type ProAnswer struct {
	TrueCount  int  `json:"true_count"`
	FalseCount int  `json:"false_count"`
	Status     bool `json:"status"`
}

func main() {
	 比对题目答案
	  对比题目答案是否正确
	 1。对比题目答案数量
	 2. 对比题目正确性
	pro1 := Pro{
		Name:    "1?single",
		Options: []string{"1", "2", "3", "4"},
		Answers: []int{0},
	}
	//
	pro2  := Pro{
		Name:    "1?single",
		Options: []string{"1","2","3","4"},
		Answers: []int{0,1},
	}
	
	//p := Pro{
	//	Name:    "1?single",
	//	Options: []string{"2","1","3","4"},
	//	Answers: []int{1,0},
	//}
	//pa := pro1.dealPro(p)
	//fmt.Println("-----: ", pa)
	// 随机题目答案
	options := pro1.randOption()
	fmt.Println("o: ", options)
}

//  获取题目正确性
func (p *Pro) dealPro(pro2 Pro) (pa ProAnswer) {
	if len(p.Answers) == len(pro2.Answers) && len(p.Answers) > 0 {
		if len(p.Options) == 0 && len(pro2.Options) == 0 {
			if p.Answers[0] == pro2.Answers[0] {
				pa.Status = true
				pa.TrueCount = 1
			} else {
				pa.Status = false
				pa.FalseCount = 1
			}
		} else {
			//  获取题目答案数组
			pro1A, _ := p.getProAnswer()
			pro2A, _ := pro2.getProAnswer()
			if len(pro1A) == len(pro2A) && len(pro1A) > 0 {
				trueLen := len(pro1A)
				trueCount := 0
				for _, t := range pro1A {
					ok := false
					for _, t1 := range pro2A {
						if t == t1 {
							ok = true
						}
					}
					if ok {
						trueCount += 1
					}
				}
				if trueCount == trueLen {
					pa.TrueCount = trueCount
					pa.Status = true
				} else {
					pa.Status = false
					pa.TrueCount = trueCount
					pa.FalseCount = trueLen - trueCount
				}

			} else {
				pa.FalseCount = 1
				pa.Status = false
			}
		}
	} else {
		pa.Status = false
		pa.FalseCount = 1
	}
	return pa
}

// 获取题目答案
func (p *Pro) getProAnswer() (as []string, las int) {
	if len(p.Options) > 0 && len(p.Answers) > 0 {
		lenO := len(p.Options)
		for _, a := range p.Answers {
			if a <= lenO-1 {
				as = append(as, p.Options[a])
			}
		}
	} else {
		if len(p.Answers) > 0 {
			for _, a := range p.Answers {
				as = append(as, fmt.Sprintf("%v", a))
			}
		}
	}
	return as, len(as)
}

// 随机选项数组
func (p *Pro) randOption() []string {
	if len(p.Options) > 0 {
		for o := len(p.Options) - 1; o > 0; o-- {
			rand.Seed(time.Now().UnixNano())
			m := rand.Intn(o + 1)
			p.Options[o], p.Options[m] = p.Options[m], p.Options[o]
		}
	}
	return p.Options
}

// 判断选项是否为空
func (p *Pro) isOptionSpace() bool {
	if len(p.Options) == 0 {
		return true
	} else {
		return false
	}
}

// 判断题目是否为空
func (p *Pro) isNameSpace() bool {
	name := strings.TrimSpace(p.Name)
	if name == "" {
		return true
	} else {
		return false
	}
}