Hackerrank Array Problem

Getting Help Code Review
1

Can someone plz help me with this Algorithm?

Alex works at a clothing store. There is a large pile of socks that must be paired by color for sale. Given an array of integers representing the color of each sock, determine how many pairs of socks with matching colors there are.

For example, there are socks with colors . There is one pair of color and one of color . There are three odd socks left, one of each color. The number of pairs is .

Function Description

Complete the sockMerchant function in the editor below. It must return an integer representing the number of matching pairs of socks that are available.

sockMerchant has the following parameter(s):

  • n : the number of socks in the pile
  • ar : the colors of each sock

Input Format

The first line contains an integer , the number of socks represented in .
The second line contains space-separated integers describing the colors of the socks in the pile.

Constraints

  • where

Output Format

Return the total number of matching pairs of socks that Alex can sell.

Sample Input

9
10 20 20 10 10 30 50 10 20

Sample Output

3

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strconv"
    "strings"
)

// Complete the sockMerchant function below.
func sockMerchant(n int32, ar []int32) int32 {
    var newValue int32 
    for _, value := range ar {
        newValue = value/n
    }
 fmt.Printf("The value of n is %v",n )
  fmt.Printf("The value of ar is %v",ar )
 return newValue
}

func main() {
    reader := bufio.NewReaderSize(os.Stdin, 1024 * 1024)

    stdout, err := os.Create(os.Getenv("OUTPUT_PATH"))
    checkError(err)

    defer stdout.Close()

    writer := bufio.NewWriterSize(stdout, 1024 * 1024)

    nTemp, err := strconv.ParseInt(readLine(reader), 10, 64)
    checkError(err)
    n := int32(nTemp)

    arTemp := strings.Split(readLine(reader), " ")

    var ar []int32

    for i := 0; i < int(n); i++ {
        arItemTemp, err := strconv.ParseInt(arTemp[i], 10, 64)
        checkError(err)
        arItem := int32(arItemTemp)
        ar = append(ar, arItem)
    }

    result := sockMerchant(n, ar)

    fmt.Fprintf(writer, "%d\n", result)

    writer.Flush()
}

func readLine(reader *bufio.Reader) string {
    str, _, err := reader.ReadLine()
    if err == io.EOF {
        return ""
    }

    return strings.TrimRight(string(str), "\r\n")
}

func checkError(err error) {
    if err != nil {
        panic(err)
    }
}

Source: Hackerrank

1 Like
2

The logic you’re using to solve the problem is incorrect, first you need to create a map (or freq table) for the different colors. Like if the array is [10, 20, 20, 10, 10, 30, 50, 10, 20], the corresponding map for this array would look like this {10: 4, 20: 3, 30: 1, 50: 1}.
Now, loop over all the values in the map and do an integral division of these values by 2 and add it to the final answer. Have a look at the code below:

func sockMerchant(n int32, ar []int32) int32 {
    freq := map[int32]int32{}
    for _, value := range ar {
        if _,ok := freq[value]; ok {
            freq[value] += 1
        }else {
            freq[value] = 1
        }
    }
    fmt.Println(freq)
    var ans int32 = 0
    for _, value := range freq {
        ans += value/2
    }
    return ans
}
3

HackerRank is the market-leading technical assessment and remote interview solution for hiring developers.

As an interviewer, I am looking for readability and code quality as well as correctness.

I usually have a model answer for comparison.

func sockMerchant(n int32, ar []int32) int32 {
	if int64(n) != int64(len(ar)) {
		panic("n != len(ar)")
	}

	// colors map[color]freq
	colors := make(map[int32]int32) // or map[int32]int32{}
	for _, color := range ar {
		colors[color]++
	}

	pairs := int32(0)
	for _, freq := range colors {
		pairs += freq / 2 // or freq >> 1
	}
	return pairs
}

In Go, n and len(ar) provide the same information. I don’t see where you recognize that.

You write

if _, ok := freq[value]; ok {
	freq[value] += 1
} else {
	freq[value] = 1
}

Which can be written in simpler form as

freq[value]++

I wonder if you have read The Go Programming Language Specification. In particular, the sections on Index expressions, The zero value, and IncDec statements.

You left a debugging statement in your code

fmt.Println(freq)

In a competitive hiring environment, small items are enough to fail an interview.

2 Likes