# Find goal difference for maximum wins and recent team with that goal difference

Geek is a big fan of the Soccer League. Recently he has got a document containing the scores of all the matches played in the League till date. Since the number of matches that have been played is too large, he has randomly selected **N** matches whose scores he is going to analyze. Each match is given in the format of **{ HT HG AT AG} **(where HT is Home team, HG is Home goal, AT is Away team, AG Away goal). Geek wants to find the **Goal Difference (GD)** [i.e., (goals scored by winning team – goals scored by losing team)] by which maximum number of times a Home Team has won a match. Next Geek also wants to find the name of the team which has most recently won a home match by this **GD**. However, Geek is very lazy and asks for your help. Can you help Geek with his analysis?

In case no home team has won in any of the N games, then output just -1.

**Note:** A Draw, ie. Both the teams have scored the same number of goals is considered as a win for the Home Team with **GD = 0**.

**Example:**

Input:N = 4

mumbai 3 goa 2

bengaluru 1 kerala 0

goa 4 hyderabad 5

bengal 3 goa 1Output:1 bengaluruExplanation:The goal difference by which a home team is winning maximum time is 1.

Mumbai and Bengaluru wins with a goal difference 1, Bengal wins with goal difference 1.

The most recent home team to win with GD = 1, is bengaluru.

Input:

N = 3

mumbai 2 Kerala 3

mumbai 6 goa 3

goa 2 bengal 4Output:3 mumbai

**Approach:** The problem can be solved with the help of hashing using the following idea:

Take two

hash maps, first one will store the non-negativeGD(Goal Difference) i.e.,HG(Home Goal) –AG(Arrival Goal), and the most recent team to win by thatGD. And the second hash map will store theGDand the corresponding frequency. If there is no non-negativeGD, then the output will be-1.

Follow the steps mentioned below to implement the approach:

- Create two maps to store the frequency and goal difference as shown above.
- Iterate the result of
**N**matches:- Get the goal difference (i.e.,
**GD = HG – AG**). - If the value is
**not negative**then the home team wins. - If the
**GD**is already present in the map, update the team corresponding to it to store the most recent team with that much goal difference. - Increment the frequency of
**GD**.

- Get the goal difference (i.e.,
- Return the
**GD**with the highest frequency and the team associated with it.

Below is the implementation of the above approach:

## C++

`// C++ code to implement the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the name of the team` `// which has most recently won a home match` `// by this GD` `void` `solve(vector<string>& HT, vector<` `int` `>& HG,` ` ` `vector<string>& AT, vector<` `int` `>& AG)` `{` ` ` `int` `N = HG.size();` ` ` `// Hash map to store gd and its frequency` ` ` `unordered_map<` `int` `, ` `int` `> gd_freq;` ` ` `// Hash map to store gd and` ` ` `// the recent home team to win` ` ` `// with that gd` ` ` `unordered_map<` `int` `, string> gd_team;` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `int` `gd = HG[i] - AG[i];` ` ` `if` `(gd >= 0) {` ` ` `gd_freq[gd]++;` ` ` `gd_team[gd] = HT[i];` ` ` `}` ` ` `}` ` ` `// Stores gd with maximum frequency` ` ` `int` `max_index = 0;` ` ` `// Stores maximum frequency` ` ` `int` `max_freq = -1;` ` ` `for` `(` `auto` `itr = gd_freq.begin();` ` ` `itr != gd_freq.end();` ` ` `itr++) {` ` ` `// To find maximum frequency` ` ` `// and the corresponding gd` ` ` `if` `(max_freq <= itr->second) {` ` ` `max_freq = itr->second;` ` ` `max_index = itr->first;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == -1) {` ` ` `cout << ` `"-1"` `;` ` ` `}` ` ` `else` `{` ` ` `cout << max_index << ` `" "` `<< gd_team[max_index];` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 4;` ` ` `// Store home teams` ` ` `vector<string> HT` ` ` `= { ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `};` ` ` `// Store goals by home teams` ` ` `vector<` `int` `> HG = { 3, 1, 4, 3 };` ` ` `// Store arrival teams` ` ` `vector<string> AT` ` ` `= { ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `};` ` ` `// Store goals by home teams` ` ` `vector<` `int` `> AG = { 2, 0, 5, 1 };` ` ` `// Function call` ` ` `solve(HT, HG, AT, AG);` ` ` `return` `0;` `}` |

## Java

`// Java code to implement the approach` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to find the name of the team` ` ` `// which has most recently won a home match` ` ` `// by this GD` ` ` `public` `static` `void` `solve(String HT[], ` `int` `HG[],` ` ` `String AT[], ` `int` `AG[])` ` ` `{` ` ` `int` `N = ` `4` `;` ` ` `// Hash map to store gd and its frequency` ` ` `Map<Integer, Integer> gd_freq` ` ` `= ` `new` `HashMap<Integer, Integer>();` ` ` `// Hash map to store gd and` ` ` `// the recent home team to win` ` ` `// with that gd` ` ` `Map<Integer, String> gd_team` ` ` `= ` `new` `HashMap<Integer, String>();` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `int` `gd = HG[i] - AG[i];` ` ` `if` `(gd >= ` `0` `) {` ` ` `int` `prev_freq = ` `0` `;` ` ` `if` `(gd_freq.get(gd) != ` `null` `) {` ` ` `prev_freq = gd_freq.get(gd);` ` ` `}` ` ` `gd_freq.put(gd, prev_freq + ` `1` `);` ` ` `gd_team.put(gd, HT[i]);` ` ` `}` ` ` `}` ` ` `// Stores gd with maximum frequency` ` ` `int` `max_index = ` `0` `;` ` ` `// Stores maximum frequency` ` ` `int` `max_freq = -` `1` `;` ` ` `for` `(Map.Entry<Integer, Integer> entry :` ` ` `gd_freq.entrySet()) {` ` ` `// To find maximum frequency and the` ` ` `// corresponding gd` ` ` `if` `(max_freq <= entry.getValue()) {` ` ` `max_freq = entry.getValue();` ` ` `max_index = entry.getKey();` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == -` `1` `) {` ` ` `System.out.println(` `"-1"` `);` ` ` `}` ` ` `else` `{` ` ` `System.out.println(max_index + ` `" "` ` ` `+ gd_team.get(max_index));` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `N = ` `4` `;` ` ` `// Store home teams` ` ` `String HT[]` ` ` `= { ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `};` ` ` `// Store goals by home teams` ` ` `int` `HG[] = { ` `3` `, ` `1` `, ` `4` `, ` `3` `};` ` ` `// Store arrival teams` ` ` `String AT[]` ` ` `= { ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `};` ` ` `// Store goals by home teams` ` ` `int` `AG[] = { ` `2` `, ` `0` `, ` `5` `, ` `1` `};` ` ` `// Function call` ` ` `solve(HT, HG, AT, AG);` ` ` `}` `}` |

## Python3

`# Python3 code to implement the approach` `# Function to find the name of the team` `# which has most recently won a home match` `# by this GD` `def` `solve(HT, HG, AT, AG) :` ` ` `N ` `=` `len` `(HG);` ` ` `# Hash map to store gd and its frequency` ` ` `gd_freq ` `=` `{};` ` ` `# Hash map to store gd and` ` ` `# the recent home team to win` ` ` `# with that gd` ` ` `gd_team ` `=` `{};` ` ` `# Inserting league data in hash maps` ` ` `for` `i ` `in` `range` `(N) :` ` ` `gd ` `=` `HG[i] ` `-` `AG[i];` ` ` ` ` `if` `(gd >` `=` `0` `) :` ` ` `gd_freq[gd] ` `=` `gd_freq.get(gd,` `0` `) ` `+` `1` `;` ` ` `gd_team[gd] ` `=` `HT[i];` ` ` `# Stores gd with maximum frequency` ` ` `max_index ` `=` `0` `;` ` ` `# Stores maximum frequency` ` ` `max_freq ` `=` `-` `1` `;` ` ` `for` `itr ` `in` `gd_freq :` ` ` `# To find maximum frequency` ` ` `# and the corresponding gd` ` ` `if` `(max_freq <` `=` `gd_freq[itr]) :` ` ` `max_freq ` `=` `gd_freq[itr];` ` ` `max_index ` `=` `itr;` ` ` `# If no home team has won` ` ` `if` `(max_freq ` `=` `=` `-` `1` `) :` ` ` `print` `(` `"-1"` `);` ` ` ` ` `else` `:` ` ` `print` `(max_index,` `" "` `,gd_team[max_index]);` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `4` `;` ` ` `# Store home teams` ` ` `HT ` `=` `[ ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `];` ` ` `# Store goals by home teams` ` ` `HG ` `=` `[ ` `3` `, ` `1` `, ` `4` `, ` `3` `];` ` ` `# Store arrival teams` ` ` `AT ` `=` `[ ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `];` ` ` `# Store goals by home teams` ` ` `AG ` `=` `[ ` `2` `, ` `0` `, ` `5` `, ` `1` `];` ` ` `# Function call` ` ` `solve(HT, HG, AT, AG);` ` ` ` ` `# This code is contributed by AnkThon` |

## C#

`// C# code to implement the approach` `using` `System;` `// class to store gd frequency and` `// the recent home team` `class` `GFG` `{` ` ` `public` `class` `goalDiff` ` ` `{` ` ` `public` `int` `frequency;` ` ` `public` `String team_name;` ` ` `}` ` ` `// Function to find the team and` ` ` `// the goal difference` ` ` `static` `void` `solve(String[] HT, ` `int` `[] HG,` ` ` `String[] AT, ` `int` `[] AG)` ` ` `{` ` ` `int` `MAX = 100;` ` ` `int` `N = 4;` ` ` `// Hash map to store gd, its frequency and` ` ` `// the recent home team to win with that gd` ` ` `goalDiff[] arr = ` `new` `goalDiff[MAX];` ` ` `for` `(` `int` `i = 0; i < MAX; i++)` ` ` `{` ` ` `arr[i] = ` `new` `goalDiff();` ` ` `arr[i].frequency = 0;` ` ` `arr[i].team_name = ` `""` `;` ` ` `}` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `{` ` ` `int` `gd = HG[i] - AG[i];` ` ` `if` `(gd >= 0)` ` ` `{` ` ` `arr[gd].frequency++;` ` ` `arr[gd].team_name = HT[i];` ` ` `}` ` ` `}` ` ` `// Stores gd with maximum frequency` ` ` `int` `max_index = 0;` ` ` `// Stores maximum frequency` ` ` `int` `max_freq = -1;` ` ` `for` `(` `int` `i = 0; i < MAX; i++)` ` ` `{` ` ` `// To find maximum frequency and` ` ` `// the corresponding gd` ` ` `if` `(max_freq <= arr[i].frequency)` ` ` `{` ` ` `max_freq = arr[i].frequency;` ` ` `max_index = i;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == -1)` ` ` `{` ` ` `Console.WriteLine(` `"-1"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `Console.WriteLine(max_index + ` `" "` ` ` `+ arr[max_index].team_name);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `N = 4;` ` ` `// Store home teams` ` ` `String[] HT = { ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `};` ` ` `// Store goals by home teams` ` ` `int` `[] HG = { 3, 1, 4, 3 };` ` ` `// Store arrival teams` ` ` `String[] AT = { ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `};` ` ` `// Store goals by home teams` ` ` `int` `[] AG = { 2, 0, 5, 1 };` ` ` `// Function call` ` ` `solve(HT, HG, AT, AG);` ` ` `}` `}` `// This code is contributed by saurabh_jaiswal.` |

## Javascript

`//JS code to implement the approach` `// Function to find the name of the team` `// which has most recently won a home match` `// by this GD` `function` `solve(HT, HG, AT, AG) ` `{` ` ` `var` `N = HG.length;` ` ` `// Hash map to store gd and its frequency` ` ` `var` `gd_freq = {};` ` ` `// Hash map to store gd and` ` ` `// the recent home team to win` ` ` `// with that gd` ` ` `var` `gd_team = {};` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `var` `i = 0; i < N; i++)` ` ` `{` ` ` `var` `gd = HG[i] - AG[i];` ` ` ` ` `if` `(gd >= 0)` ` ` `{` ` ` `if` `(!gd_freq.hasOwnProperty(gd))` ` ` `gd_freq[gd] = 1;` ` ` `else` ` ` `gd_freq[gd] = gd_freq[gd] + 1;` ` ` `gd_team[gd] = HT[i];` ` ` `}` ` ` `}` ` ` `// Stores gd with maximum frequency` ` ` `var` `max_index = 0;` ` ` `// Stores maximum frequency` ` ` `var` `max_freq = -1;` ` ` ` ` `for` `(const itr ` `in` `gd_freq)` ` ` `{` ` ` `// To find maximum frequency` ` ` `// and the corresponding gd` ` ` `if` `(max_freq <= gd_freq[itr])` ` ` `{` ` ` `max_freq = gd_freq[itr];` ` ` `max_index = itr;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == -1)` ` ` `console.log(` `"-1"` `);` ` ` ` ` `else` ` ` `console.log(max_index, gd_team[max_index]);` `}` `// Driver Code` `var` `N = 4;` `// Store home teams` `var` `HT = [ ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `];` `// Store goals by home teams` `var` `HG = [ 3, 1, 4, 3 ];` `// Store arrival teams` `var` `AT = [ ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `];` `// Store goals by home teams` `var` `AG = [ 2, 0, 5, 1 ];` `// Function call` `solve(HT, HG, AT, AG);` ` ` `// This code is contributed by phasing17` |

**Output**

1 bengaluru

**Time Complexity:** O(N)**Auxiliary Space:** O(N)

**Alternative Approach:** The problem can also be solved based on the concept of **class** and **structure** as per the following idea:

Create a structure or class with objects as

frequencyandteam_name(which will store the most recent team who won with that Goal difference). Create an array of the declared structure or class with the maximum possible goal difference as its size which will work as a hash table where goal difference is the key.

Follow the steps mentioned below to implement the idea:

- Create a class or structure as mentioned above and an array (say
**arr[]**)of that class or structure. - Iterate over all the records of the match:
- Calculate the goal difference (i.e.,
**GD = HG – AG**). - If
**GD**is not negative then the home team wins. - Fill
**arr[GD]**with the updated frequency and the current team name as this is the team to win the match with a goal difference of**GD**.

- Calculate the goal difference (i.e.,
- Now iterate
**arr[]**:- If frequency at
**arr[i]**is the maximum then update the maximum frequency and the associated team with the data of arr[i].

- If frequency at
- Return the maximum frequency and the team associated with that as the answer.

Below is the implementation of the above approach:

## C++

`// C++ code to implement the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Maximum possible goal difference` `#define MAX 100` `// Structure with frequency` `// and recent team name` `struct` `goalDiff {` ` ` `int` `frequency;` ` ` `string team_name;` `};` `// Function to find the team` `// and the goal difference` `void` `solve(vector<string>& HT, vector<` `int` `>& HG,` ` ` `vector<string>& AT, vector<` `int` `>& AG)` `{` ` ` `int` `N = 4;` ` ` `// Array to store gd, its frequency and` ` ` `// the recent home team to win with that gd` ` ` `goalDiff arr[MAX];` ` ` `for` `(` `int` `i = 0; i < MAX; i++) {` ` ` `arr[i].frequency = 0;` ` ` `arr[i].team_name = ` `""` `;` ` ` `}` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `int` `gd = HG[i] - AG[i];` ` ` `if` `(gd >= 0) {` ` ` `arr[gd].frequency++;` ` ` `arr[gd].team_name = HT[i];` ` ` `}` ` ` `}` ` ` `int` `max_index = 0;` ` ` `int` `max_freq = -1;` ` ` `for` `(` `int` `i = 0; i < MAX; i++) {` ` ` `// To find maximum frequency and` ` ` `// the corresponding gd` ` ` `if` `(max_freq <= arr[i].frequency) {` ` ` `max_freq = arr[i].frequency;` ` ` `max_index = i;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == 0) {` ` ` `cout << ` `"-1"` `;` ` ` `}` ` ` `else` `{` ` ` `cout << max_index << ` `" "` ` ` `<< arr[max_index].team_name;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 4;` ` ` `// Store home teams` ` ` `vector<string> HT` ` ` `= { ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `};` ` ` `// Store goals by home teams` ` ` `vector<` `int` `> HG = { 3, 1, 4, 3 };` ` ` `// Store arrival teams` ` ` `vector<string> AT` ` ` `= { ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `};` ` ` `// store goals by home teams` ` ` `vector<` `int` `> AG = { 2, 0, 5, 1 };` ` ` `// Function call` ` ` `solve(HT, HG, AT, AG);` ` ` `return` `0;` `}` |

## Java

`// Java code to implement the approach` `import` `java.io.*;` `import` `java.util.*;` `// class to store gd frequency and` `// the recent home team` `class` `goalDiff {` ` ` `int` `frequency;` ` ` `String team_name;` `}` `class` `Main {` ` ` `// Function to find the team and` ` ` `// the goal difference` ` ` `static` `void` `solve(String HT[], ` `int` `HG[],` ` ` `String AT[], ` `int` `AG[])` ` ` `{` ` ` `int` `MAX = ` `100` `;` ` ` `int` `N = ` `4` `;` ` ` `// Hash map to store gd, its frequency and` ` ` `// the recent home team to win with that gd` ` ` `goalDiff arr[] = ` `new` `goalDiff[MAX];` ` ` `for` `(` `int` `i = ` `0` `; i < MAX; i++) {` ` ` `arr[i] = ` `new` `goalDiff();` ` ` `arr[i].frequency = ` `0` `;` ` ` `arr[i].team_name = ` `""` `;` ` ` `}` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) {` ` ` `int` `gd = HG[i] - AG[i];` ` ` `if` `(gd >= ` `0` `) {` ` ` `arr[gd].frequency++;` ` ` `arr[gd].team_name = HT[i];` ` ` `}` ` ` `}` ` ` `// Stores gd with maximum frequency` ` ` `int` `max_index = ` `0` `;` ` ` `// Stores maximum frequency` ` ` `int` `max_freq = -` `1` `;` ` ` `for` `(` `int` `i = ` `0` `; i < MAX; i++) {` ` ` `// To find maximum frequency and` ` ` `// the corresponding gd` ` ` `if` `(max_freq <= arr[i].frequency) {` ` ` `max_freq = arr[i].frequency;` ` ` `max_index = i;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == -` `1` `) {` ` ` `System.out.println(` `"-1"` `);` ` ` `}` ` ` `else` `{` ` ` `System.out.println(max_index + ` `" "` ` ` `+ arr[max_index].team_name);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `N = ` `4` `;` ` ` `// Store home teams` ` ` `String HT[]` ` ` `= { ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `};` ` ` `// Store goals by home teams` ` ` `int` `HG[] = { ` `3` `, ` `1` `, ` `4` `, ` `3` `};` ` ` `// Store arrival teams` ` ` `String AT[]` ` ` `= { ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `};` ` ` `// Store goals by home teams` ` ` `int` `AG[] = { ` `2` `, ` `0` `, ` `5` `, ` `1` `};` ` ` `// Function call` ` ` `solve(HT, HG, AT, AG);` ` ` `}` `}` |

## Python3

`# Python3 code to implement the approach` `# Maximum possible goal difference` `MAX` `=` `100` `# class with frequency` `# and recent team name` `class` `goalDiff:` ` ` `def` `__init__(` `self` `,frequency,team_name):` ` ` `self` `.frequency ` `=` `frequency` ` ` `self` `.team_name ` `=` `team_name` ` ` `# Function to find the team` `# and the goal difference` `def` `solve(HT, HG, AT, AG):` ` ` `global` `MAX` ` ` `N ` `=` `4` ` ` `# Array to store gd, its frequency and` ` ` `# the recent home team to win with that gd` ` ` `arr ` `=` `[` `0` `for` `i ` `in` `range` `(` `MAX` `)]` ` ` `for` `i ` `in` `range` `(` `MAX` `):` ` ` `arr[i] ` `=` `goalDiff(` `0` `,"")` ` ` `# Inserting league data in hash maps` ` ` `for` `i ` `in` `range` `(N):` ` ` `gd ` `=` `HG[i] ` `-` `AG[i]` ` ` `if` `(gd >` `=` `0` `):` ` ` `arr[gd].frequency ` `+` `=` `1` ` ` `arr[gd].team_name ` `=` `HT[i]` ` ` `max_index ` `=` `0` ` ` `max_freq ` `=` `-` `1` ` ` `for` `i ` `in` `range` `(` `MAX` `):` ` ` `# To find maximum frequency and` ` ` `# the corresponding gd` ` ` `if` `(max_freq <` `=` `arr[i].frequency):` ` ` `max_freq ` `=` `arr[i].frequency` ` ` `max_index ` `=` `i` ` ` `# If no home team has won` ` ` `if` `(max_freq ` `=` `=` `0` `):` ` ` `print` `(` `"-1"` `)` ` ` `else` `:` ` ` `print` `(f` `"{max_index} {arr[max_index].team_name}"` `)` ` ` `# Driver Code` `N ` `=` `4` `# Store home teams` `HT ` `=` `[ ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `]` `# Store goals by home teams` `HG ` `=` `[ ` `3` `, ` `1` `, ` `4` `, ` `3` `]` `# Store arrival teams` `AT ` `=` `[ ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `]` `# store goals by home teams` `AG ` `=` `[ ` `2` `, ` `0` `, ` `5` `, ` `1` `]` `# Function call` `solve(HT, HG, AT, AG)` `# This code is contributed by shinjanpatra` |

## C#

`// C# code to implement the approach` `using` `System;` `// class to store gd frequency and` `// the recent home team` `class` `goalDiff {` ` ` `public` `int` `frequency;` ` ` `public` `string` `team_name;` `}` `class` `GFG {` ` ` `// Function to find the team and` ` ` `// the goal difference` ` ` `static` `void` `solve(` `string` `[] HT, ` `int` `[] HG, ` `string` `[] AT,` ` ` `int` `[] AG)` ` ` `{` ` ` `int` `MAX = 100;` ` ` `int` `N = 4;` ` ` `// Hash map to store gd, its frequency and` ` ` `// the recent home team to win with that gd` ` ` `goalDiff[] arr = ` `new` `goalDiff[MAX];` ` ` `for` `(` `int` `i = 0; i < MAX; i++) {` ` ` `arr[i] = ` `new` `goalDiff();` ` ` `arr[i].frequency = 0;` ` ` `arr[i].team_name = ` `""` `;` ` ` `}` ` ` `// Inserting league data in hash maps` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `int` `gd = HG[i] - AG[i];` ` ` `if` `(gd >= 0) {` ` ` `arr[gd].frequency++;` ` ` `arr[gd].team_name = HT[i];` ` ` `}` ` ` `}` ` ` `// Stores gd with maximum frequency` ` ` `int` `max_index = 0;` ` ` `// Stores maximum frequency` ` ` `int` `max_freq = -1;` ` ` `for` `(` `int` `i = 0; i < MAX; i++) {` ` ` `// To find maximum frequency and` ` ` `// the corresponding gd` ` ` `if` `(max_freq <= arr[i].frequency) {` ` ` `max_freq = arr[i].frequency;` ` ` `max_index = i;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == -1) {` ` ` `Console.WriteLine(` `"-1"` `);` ` ` `}` ` ` `else` `{` ` ` `Console.WriteLine(max_index + ` `" "` ` ` `+ arr[max_index].team_name);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(` `string` `[] args)` ` ` `{` ` ` `// Store home teams` ` ` `string` `[] HT` ` ` `= { ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `};` ` ` `// Store goals by home teams` ` ` `int` `[] HG = { 3, 1, 4, 3 };` ` ` `// Store arrival teams` ` ` `string` `[] AT` ` ` `= { ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `};` ` ` `// Store goals by home teams` ` ` `int` `[] AG = { 2, 0, 5, 1 };` ` ` `// Function call` ` ` `solve(HT, HG, AT, AG);` ` ` `}` `}` `// This code is contributed by phasing17` |

## Javascript

`<script>` `// JavaScript code to implement the approach` `// Maximum possible goal difference` `const MAX = 100` `// class with frequency` `// and recent team name` `class goalDiff {` ` ` `constructor(frequency,team_name){` ` ` `this` `.frequency = frequency;` ` ` `this` `.team_name = team_name;` ` ` `}` `}` `// Function to find the team` `// and the goal difference` `function` `solve(HT, HG, AT, AG)` `{` ` ` `let N = 4;` ` ` `// Array to store gd, its frequency and` ` ` `// the recent home team to win with that gd` ` ` `let arr = ` `new` `Array(MAX);` ` ` `for` `(let i = 0; i < MAX; i++) {` ` ` `arr[i] = ` `new` `goalDiff(0,` `""` `)` ` ` `}` ` ` `// Inserting league data in hash maps` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `let gd = HG[i] - AG[i];` ` ` `if` `(gd >= 0) {` ` ` `arr[gd].frequency++;` ` ` `arr[gd].team_name = HT[i];` ` ` `}` ` ` `}` ` ` `let max_index = 0;` ` ` `let max_freq = -1;` ` ` `for` `(let i = 0; i < MAX; i++) {` ` ` `// To find maximum frequency and` ` ` `// the corresponding gd` ` ` `if` `(max_freq <= arr[i].frequency) {` ` ` `max_freq = arr[i].frequency;` ` ` `max_index = i;` ` ` `}` ` ` `}` ` ` `// If no home team has won` ` ` `if` `(max_freq == 0) {` ` ` `document.write(` `"-1"` `,` `"</br>"` `);` ` ` `}` ` ` `else` `{` ` ` `document.write(max_index,` `" "` `,arr[max_index].team_name,` `"</br>"` `);` ` ` `}` `}` `// Driver Code` `let N = 4;` `// Store home teams` `let HT = [ ` `"mumbai"` `, ` `"bengaluru"` `, ` `"goa"` `, ` `"bengal"` `];` `// Store goals by home teams` `let HG = [ 3, 1, 4, 3 ];` `// Store arrival teams` `let AT = [ ` `"goa"` `, ` `"kerala"` `, ` `"hyderabad"` `, ` `"goa"` `];` `// store goals by home teams` `let AG = [ 2, 0, 5, 1 ];` `// Function call` `solve(HT, HG, AT, AG);` `// This code is contributed by shinjanpatra` `</script>` |

**Output**

1 bengaluru

**Time Complexity:** O(N)**Auxiliary Space:** O(N)