Golang Program that Removes Duplicate Elements From the Array

Arrays in Golang or Go programming language is much similar to other programming languages. In the program, sometimes we need to store a collection of data of the same type, like a list of student marks. Such type of collection is stored in a program using an Array. An array is a fixed-length sequence that is used to store homogeneous elements in the memory. Due to their fixed length array are not much popular like Slice in Go language.

In an array, you are allowed to store zero or more than zero elements in it. The elements of the array are indexed by using the [] index operator with their zero-based position, means the index of the first element is array[0] and the index of the last element is array[len(array)-1].

To remove duplicate elements from an array we map the int items to boolean data type and set it to true for the first occurrence of the elements and thereby append it to another array to get the removed duplicated elements array

Input : [7, 3, 6, 1, 8, 1, 1, 3, 4, 5, 12]
Output : [7, 6, 4, 8, 5, 12]
The elements present more than once, the duplicates are removed

Lets look into the Golang program and understand the code :

import "fmt"

Package fmt implements formatted I/O with functions analogous to C’s printf and scanf. 

func unique(arr []int) []int {

The function definition that we define to remove duplicate elements with the parameter as an input array ‘arr’ and return an array of type ‘[ ]int’

occurred := map[int]bool{}
result:=[]int{}

Here we create a map variable occurred that will map int data type to boolean data type for every element present in the array. We create and array ‘result’ that will store the unique elements from the given items and return it to the main function

 for e:= range arr {
     if occurred[arr[e]] != true {
     occurred[arr[e]] = true
         result = append(result, arr[e])
     }
  }
return result

We iterate through the array in for loop and check if the mapped variable occurred[arr[(loop variable)]] is true or not. Initially none of the mapped variable for each index is true. So when the element is encountered first time we change the value to true and append it to an array  result. The next time when the duplicate elements are found it will check for the condition if occurred[arr[e]] is true or not, it will be true as it was encountered earlier so the block is not executed and the duplicate elements does not get appended to the result array. Finally we return the array

func main() {
    array1 := []int{1, 5, 3, 4, 1, 6, 6, 6, 8, 7, 13, 5}
    fmt.Println(array1) 
    unique_items := unique(array1)
    fmt.Println(unique_items)
}

In the function main array1 is initialized with the values then we print the initial array and call the function unique to execute the above function and in turn returns an array which we print it as ‘unique_items’

Output:

[1 5 3 4 1 6 6 6 8 7 13 5]
[1 5 3 4 6 8 7 13]