我的编程空间,编程开发者的网络收藏夹
学习永远不晚

如何使用 Golang 在结构体切片中查找最常见的整数

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

如何使用 Golang 在结构体切片中查找最常见的整数

Golang不知道大家是否熟悉?今天我将给大家介绍《如何使用 Golang 在结构体切片中查找最常见的整数》,这篇文章主要会讲到等等知识点,如果你在看完本篇文章后,有更好的建议或者发现哪里有问题,希望大家都能积极评论指出,谢谢!希望我们能一起加油进步!

问题内容

*** 免责声明:我不是专业的开发人员,已经对 golang 进行了大约 8 个月的修改(udemy + youtube),但仍然不知道如何解决如下所示的简单问题..

以下是问题的摘要:

  • 我试图从来自解码的 .json 文件(包含字符串“name”和整数“age”)的结构中找到最常见的“age”。

  • 之后我需要根据“年龄”的最大出现频率打印“姓名”。

  • 根据“年龄”最大出现次数打印的“姓名”需要按字母顺序排序

输入(.json):

[
{"name": "john","age": 15},
{"name": "peter","age": 12},
{"name": "roger","age": 12},
{"name": "anne","age": 44},
{"name": "marry","age": 15},
{"name": "nancy","age": 15}
]

输出:['约翰'、'玛丽'、'南希']。

解释:因为数据中出现次数最多的年龄是 15(出现了 3 次),所以输出应该是一个字符串数组,其中包含三个人的年龄 姓名,在本例中应为 ['john', 'mary', 'nancy']。

异常:

  • 如果有多个“年龄”具有相同的最大出现次数,我需要将数据拆分并将它们打印到不同的数组中(即当“anne”年龄为 12 时,结果为:['john' ,“玛丽”,“南希”],[“安妮”,“彼得”,“罗杰”]

这是我尝试过的(在 golang 中):

package main
{
import (
    "encoding/json"
    "fmt"
    "os"
    "sort"
)
// 1. preparing the empty struct for .json
type passanger struct {
    name string `json:"name"`
    age  int    `json:"age"`
}
func main() {
    // 2. load the json file
    content, err := os.readfile("passanger.json")
    if err != nil {
        fmt.println(err.error())
    }
    // 3. parse json file to slice
    var passangers []passanger
    err2 := json.unmarshal(content, &passangers)
    if err2 != nil {
        fmt.println("error json unmarshalling")
        fmt.println(err2.error())
    }
    // 4. find most frequent age numbers (?)
    for _, v := range passangers {
        // this code only show the age on every line
        fmt.println(v.age)
    }
    // 5. print the name and sort them apabethically (?)
       // use sort.slice package
       // implement group based by "max-occurence-age"
}

从昨天开始就被困住了,我也尝试实现许多编码挑战问题的解决方案,例如:

func majorityelement(arr int) int {
    sort.ints(arr)
    return arr[len(arr)/2]
}

但我仍然在努力理解如何将 passanger 切片中的“age”值作为整数输入(arr int)处理到上面的代码。

我在网上找到的其他解决方案是通过迭代 trough map[int]int 来找到最大频率:

func main(){
    arr := []int{90, 70, 30, 30, 10, 80, 40, 50, 40, 30}
    freq := make(map[int]int)
    for _ , num :=  range arr {
        freq[num] = freq[num]+1
    }
    fmt.Println("Frequency of the Array is : ", freq)
}

但是,.json 文件不仅包含整数(年龄),还包含字符串(名称)格式,我仍然不知道如何分别处理“名称”和“年龄”..

我真的需要适当的指导。

*** 这是我上面提到的源代码 (main.go) 和 (.json) 文件: https://github.com/ariejanuarb/golang-json


正确答案


在我大学的第一年,我的老师总是向我和我的同学重复一些事情,不要先写代码,特别是如果你是初学者,请按照以下步骤操作:

  • 写下您希望发生的事情
  • 将问题详细化为小步骤
  • 写出分支时的所有场景和案例
  • 编写输入和输出(方法/函数签名)
  • 检查它们是否合适

让我们按照以下步骤操作...

写下你想要发生的事情

您已经很好地定义了您的问题,因此我将跳过此步骤。

让我们进一步详细说明

  1. 您有乘客名单
  2. 您想按乘客的年龄对乘客进行分组
  3. 您想查看哪些最常见/乘客最多。
  4. 您想按字母顺序打印姓名

分支

  • 场景一:一组的规模比其他组的规模大。
  • 场景二:两个或多个组大小相同且比其他组大。

可能还有更多场景,但你可以找到它们

输入输出??

现在我们已经找到了必须做什么,我们将检查每个步骤的输入和输出以实现此目标。

步骤:

  1. 您有乘客名单
  • 输入 => 无或文件名(字符串)
  • 输出 => []乘客
  • 您想按乘客的年龄对乘客进行分组
    • input => []passenger // 乘客列表
    • output => map[int][]int 或 map[int][]&passenger // 年龄组

    第一种,括号里面的是整个群体的年龄。

    第二种类型是包含以下任一内容的列表:

    • 乘客在列表中的位置
    • 物体/乘客在内存中的地址

    只要我们可以轻松地从列表中检索乘客而无需再次迭代即可,这并不重要。

  • 您想查看哪些最常见/乘客最多。
    • 输入 => 组(年龄组)

    所以这里我们有场景 1 和 2 分支...这意味着它必须对所有场景都有效或者使用条件来分支它们。

    • 场景 1 的输出 => 最常见年龄 (int)
    • 场景 2 的输出 => 最常见年龄 ([]int)

    我们可以看到场景 1 的输出可以与场景 2 的输出合并

  • 您想要按字母顺序打印一个列表中所有乘客的姓名 年龄组

    • 输入 => 群组 ([]乘客) + 年龄 ([]int) + 乘客列表 ([]乘客)。
    • 输出=>字符串或[]字节或什么都没有,如果你只是打印它......

    说实话,如果你想的话,你可以跳过这个。

  • 检查后,开始编码

    让我们首先创建符合我们签名的函数

    type passenger struct {
        name string `json:"name"`
        age  int    `json:"age"`
    }
    
    func getpassengerlist() []passenger{
       // 2. load the json file
       content, err := os.readfile("passanger.json")
       if err != nil {
           fmt.println(err.error())
       }
    
       // 3. parse json file to slice
       var passengers []passenger
     
       err2 := json.unmarshal(content, &passengers)
       if err2 != nil {
           fmt.println("error json unmarshalling")
           fmt.println(err2.error())
       }
    
       return passengers
    }
    
    // 4a. group by age
    func groupbyage(passengers []passenger) map[int][]int {
        group := make(map[int][]int, 0)
    
        for index, passenger := range passengers {
            agegroup := group[passenger.age]
            agegroup = append(agegroup, index)
            group[passenger.age] = agegroup
        }
    
        return group
    }
    
    // 4b. find the most frequent age numbers
    
    func findmostcommonage(agegroups map[int][]int) []int {
        mostfrequentages := make([]int, 0)
        biggestgroupsize := 0
    
        // find most frequent age numbers
        for age, agegroup := range agegroups {
            // is most frequent age
            if biggestgroupsize < len(agegroup) {
                biggestgroupsize = len(agegroup)
                mostfrequentages = []int{age}
            } else if biggestgroupsize == len(agegroup) { // is one of the most frequent age
                mostfrequentages = append(mostfrequentages, age)
            }
            // is not one of the most frequent age so does nothing
        }
    
        return mostfrequentages
    }
    
    func main() {
        passengers := loadpassengers()
    
        // i am lazy but if you want you could sort the
        // smaller slice before printing to increase performance
        sort.slice(passengers, func(i, j int) bool {
            if passengers[i].age == passengers[j].age {
                return passengers[i].name < passengers[j].name
            }
            return passengers[i].age < passengers[j].age
        })
    
        // age => []position
        // length of the array count as the number of occurences
        agegrouper := groupbyage(passengers)
    
        mostfrequentages := findmostcommonage(agegrouper)
    
        // print the passenger
        for _, age := range mostfrequentages {
            fmt.println("{")
            for _, passengerindex := range agegrouper[age] {
                fmt.println("\t", passengers[passengerindex].name)
            }
            fmt.println("}")
        }
    }
    
    
    

    应该比

    更复杂
    • 按年龄和名称对源切片进行排序
    • 将其分解为具有共同年龄的序列,并且
    • 在进行过程中,跟踪最常见的内容

    类似这样的事情:

    https://goplay.tools/snippet/6pCpkTEaDXN

    type person struct {
        age  int
        name string
    }
    
    func mostcommonage(persons []person) (mostcommonage int, names []string) {
      
      sorted := make([]person, len(persons))
      copy(sorted, persons)
      
      // sort the slice by age and then by name
      sort.slice(sorted, func(x, y int) bool {
        left, right := sorted[x], sorted[y]
        
        switch {
        case left.age < right.age:
          return true
        case left.age > right.age:
          return false
        default:
          return left.name < right.name
        }
      })
    
      updatemostcommonage := func(seq []person) (int, []string) {
        
        if len(seq) > len(names) {
          
          buf := make([]string, len(seq))
          for i := 0; i < len(seq); i++ {
            buf[i] = seq[i].name
          }
          
          mostcommonage = seq[0].age
          names = buf
          
        }
    
        return mostcommonage, names
      
      }
    
      for lo, hi := 0, 0; lo < len(sorted); lo = hi {
        
        for hi = lo; hi < len(sorted) && sorted[lo].age == sorted[hi].age; {
          hi++
        }
        
        mostcommonage, names = updatemostcommonage(sorted[lo:hi])
        
      }
    
      return mostcommonage, names
    }

    另一种方法使用更多内存,但更简单一些。在这里,我们按年龄构建一个姓名映射,然后对其进行迭代以查找具有最长姓名列表的键。

    https://goplay.tools/snippet/_zmMys516IM

    type Person struct {
        Age  int
        Name string
    }
    
    func MostCommonAge(persons []Person) (mostCommonAge int, names []string) {
        namesByAge := map[int][]string{}
    
        for _, p := range persons {
            value, found := namesByAge[p.Age]
            if !found {
                value = []string{}
            }
            namesByAge[p.Age] = append(value, p.Name)
        }
    
        for age, nameList := range namesByAge {
            if len(nameList) > len(names) {
                mostCommonAge, names = age, nameList
            }
        }
    
        return mostCommonAge, names
    }

    理论要掌握,实操不能落!以上关于《如何使用 Golang 在结构体切片中查找最常见的整数》的详细介绍,大家都掌握了吧!如果想要继续提升自己的能力,那么就来关注编程网公众号吧!

    免责声明:

    ① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

    ② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

    如何使用 Golang 在结构体切片中查找最常见的整数

    下载Word文档到电脑,方便收藏和打印~

    下载Word文档

    猜你喜欢

    如何使用 Golang 在结构体切片中查找最常见的整数

    Golang不知道大家是否熟悉?今天我将给大家介绍《如何使用 Golang 在结构体切片中查找最常见的整数》,这篇文章主要会讲到等等知识点,如果你在看完本篇文章后,有更好的建议或者发现哪里有问题,希望大家都能积极评论指出,谢谢!希望我们能一
    如何使用 Golang 在结构体切片中查找最常见的整数
    2024-04-04

    编程热搜

    • Python 学习之路 - Python
      一、安装Python34Windows在Python官网(https://www.python.org/downloads/)下载安装包并安装。Python的默认安装路径是:C:\Python34配置环境变量:【右键计算机】--》【属性】-
      Python 学习之路 - Python
    • chatgpt的中文全称是什么
      chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型,它能够通过学习和理解人类的语言来进行对话,还能根据聊天的上下文进行互动,并协助人类完成一系列
      chatgpt的中文全称是什么
    • C/C++中extern函数使用详解
    • C/C++可变参数的使用
      可变参数的使用方法远远不止以下几种,不过在C,C++中使用可变参数时要小心,在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少,否则会产生访问越界,运气不好的话还会导致程序崩溃
      C/C++可变参数的使用
    • css样式文件该放在哪里
    • php中数组下标必须是连续的吗
    • Python 3 教程
      Python 3 教程 Python 的 3.0 版本,常被称为 Python 3000,或简称 Py3k。相对于 Python 的早期版本,这是一个较大的升级。为了不带入过多的累赘,Python 3.0 在设计的时候没有考虑向下兼容。 Python
      Python 3 教程
    • Python pip包管理
      一、前言    在Python中, 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具: easy_install  和  pip , 目前官方推荐使用 pip。    
      Python pip包管理
    • ubuntu如何重新编译内核
    • 改善Java代码之慎用java动态编译

    目录