What to do before implementing a solution

During my first years of college, my teachers would always repeat something to me and my fellow classmates, don't write code first, especially if you are a beginner, follow these steps instead:

• Write what you want to happen
• Details the problem into small steps
• Write all scenarios and cases when they branch out
• Write input and output (method/function signature)
• Check they fit each other

Let's follow these steps...

Write what you want to happen

You have well defined your problem so i will skip this step.

Let's detail this further

1. You have a passenger list
2. You want to group the passengers by their age
3. You want to look which are the most common/which have the most passengers.
4. You want to print the name in alphabetical order

Branching out

• Scenario one: one group has a bigger size than all others.
• Scenario two: two or more groups has the same size and are bigger than the others.

There might more scenario but they are yours to find

input output ??

Well now that we have found out what we must be doing, we are going to check the input and output of each steps to achieve this goal.

the steps:

1. You have a passenger list

• input => none or filename (string)
• output => []Passenger

2. You want to group the passengers by their age

• input => []Passenger // passenger list
• output => map[int][]int or map[int][]&Passenger // ageGroups

The first type, the one inside the bracket is the age of the whole group.

The second type, is a list that contains either:

• the passenger's position within the list
• the address of the object/passenger in the memory

it is not important as long as we can retrieve back easily the passenger from the list without iterating it back again.

3. You want to look which are the most common/which have the most passengers.

• input => groups (ageGroups)

so here we have scenario 1 and 2 branching out... which mean that it must either be valid for all scenario or use a condition to branch them out.

• output for scenario 1 => most common age (int)
• output for scenario 2 => most common ages ([]int)

we can see that the output for scenario 1 can be merged with the output of scenario 2

4. You want to print the name in alphabetical order of all passengers in an ageGroup

   • input => groups ([]Passenger) + ages ([]int) + passenger list ([]Passenger).
   • output => string or []byte or nothing if you just print it...

   to be honest, you can skip this one if you want to.

After checking, time to code

let's create functions that fit our signature first

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("}")
    }
}