Climbing The Leaderboard Hackerrank Solutions in Golang

Clue :

An arcade game player wants to climb to the top of the leaderboard and track their ranking. The game uses Dense Ranking, so its leaderboard works like this:

1. The player with the highest score is ranked number 1 on the leaderboard.
2. Players who have equal scores receive the same ranking number, and the next player(s) receive the immediately following ranking number.

This is my code solution for climbing the leaderboard, 8/12 test case is passed. but 4 case is timeout. any solution for boosting the performance of my code?

func contains(s []int32, e int32) bool {
    for _, a := range s {
        if a == e {
            return true
        }
    }
    return false
}

func remove(slice []int32, s int) []int32 {
    return append(slice[:s], slice[s+1:]...)
}

func climbingLeaderboard(ranked []int32, player []int32) []int32 {
    // Write your code here
    for i := 0; i < len(ranked); i++ {
        if contains(ranked[i+1:], ranked[i]) {
            ranked = remove(ranked, i)
            i--
        }
    }
    sort.Slice(ranked, func(i, j int) bool { return ranked[i] < ranked[j] })
    var result = make([]int32, len(player))

    if len(ranked) == 1 {
        for i := 0; i < len(player); i++ {
            if player[i] > ranked[0] {
                result[i] = 1
            } else if player[0] == ranked[0] {
                result[i] = 1
            } else if player[0] < ranked[0] {
                result[i] = 2
            }
        }
    } else {
        for i := 0; i < len(player); i++ {
            l := len(ranked)
            l32 := int32(l)
            p := player[i]
            var temp int32
            for j := 1; j < l; j++ {
                if p > ranked[j] {
                    temp = 1
                } else if p > ranked[j-1] && p < ranked[j] {
                    temp = l32 - int32(j) + 1
                    break
                } else if p == ranked[j-1] {
                    temp = l32 - int32(j) + 1
                    break
                } else if p < ranked[j-1] {
                    temp = l32 + 1
                    break
                }
            }
            result[i] = temp
            temp = 0
        }
    }
    return result
}