## Factorials of n > 20 can't be stored even in a 64-bit long variable. Big integers must be used for such calculations.

In languages like Golang, we don't need extra steps to calculate large numbers since we have the `math/big` package to handle big numbers.

```golang
func factorial(n int64) *big.Int {
    if n == 1 {
        return big.NewInt(1)
    }
    
    value := new(big.Int).SetInt64(n)
    
    return value.Mul(value, factorial(n - 1))
}
 
func extraLongFactorials(n int32) {
    result := factorial(int64(n))
    fmt.Print(result)
}
```


 Factorials of n > 20 can't be stored even in a 64-bit long variable. Big integers must be used for such calculations.

 🦒 Extra Long Factorial

@bero_1

## 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:

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

## Example
- ranked = [100, 90, 90, 80]
- player = [70, 80, 105]

The ranked players will have ranks 1, 2, 2, and 3, respectively. If the player's scores are 70, 80 and 105, their rankings after each game are 4th, 3rd and 1 st Return [4, 3, 1].

## Function Description
Complete the climbingLeaderboard function in the editor below. climbingLeaderboard has the following parameter(s):
- int ranked[n]: the leaderboard scores
- int player [m]: the player's scores

## Returns
- int[m]: the player's rank after each new score

## Resolution
When I first took a look at this problem It sounded like easy peasy for me, so in more or less 15 minutes I came up with this solution:

```golang
func getPosition(ranked []int32, player int32) int32 {
    playerToPosition := make(map[int32]int32)
    position := int32(1)
    
    for _, v := range ranked {
        if playerToPosition[v] == 0 {
            playerToPosition[v] = position
            position++
        }
        
        if player >= v {
            return playerToPosition[v]
        }
    }
    
    return position
}

func climbingLeaderboard(ranked []int32, player []int32) []int32 {
    var newRank []int32 

    for _, v := range player {
        position := getPosition(ranked, v)
        newRank = append(newRank, position)
    }
    
    return newRank
}
```

But as soon I ran the code I found out that the real problem was not the solution, but the optimization of the solution. That code that I wrote was only able to pass 8 of the 12 tests of the hackerrank platform.

After digging deeper for a couple of hours I realized that the true key to solving this problem is to notice that we don't need to traverse the ranked slice to each player, since the player slice is sorted in a crescent way we can assume that `p2` is going to be in a position equal or greater than `p1`, so instead of going to the beginning of the array, we can continue from the last position.

```golang
func climbingLeaderboard(ranked []int32, player []int32) []int32 {
    noDupRank := make([]int32, 0, len(ranked))
    noDupRank = append(noDupRank, ranked[0])
    
    for i := 1; i < len(ranked); i++ {
        if ranked[i] != ranked[i -1] {
            noDupRank = append(noDupRank, ranked[i])
        }    
    }
     
    var playerHank []int32  
    var position = int32(len(noDupRank) + 1)

    for _, v := range player {
        for position > 1 && v >= noDupRank[position - 2] {
            position--
        }
        
        playerHank = append(playerHank, position)
    }
    
    return playerHank
}
```


 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:

🕹️ Climbing the Leader


## We define a magic square to be an n × m matrix of distinct positive integers from 1 to n^2 where the sum of any row, column, or diagonal of length n is always equal to the same number: the magic constant.

You will be given a 3 x 3 matrix s of integers in the inclusive range [1, 9]. We can convert any digit a to any other digit b in the range [1, 9] at cost of la - b|. Given s, convert it into a magic square at minimal cost. Print this cost on a new line.
Note: The resulting magic square must contain distinct integers in the inclusive range [1, 9].
Example
$s = [[5, 3, 4], [1, 5, 8], [6, 4, 21]]
The matrix looks like this:

```
5 3 4
1 5 8
6 4 2
```

We can convert it to the following magic square:

```
8 3 4
1 5 9
6 7 2
```

This took three replacements at a cost of |15 - 81| + |18 - 91| + |14 - 7| = 7.

## Function Description

Complete the formingMagicSquare function in the editor below.

formingMagicSquare has the following parameter(s):

int s[3][3]: a   3x3 array of integers

## Returns

int: the minimal total cost of converting the input square to a magic square

## Input Format

Each of the 3 lines contains three space-separated integers of a row s[i]

## Resolution
The key to solving this problem is to find out that there is only one sequence of distinct numbers positioned in a matrix to produce a magic square. But we can come up with variations of the matrix by rotating the magic square and by mirroring the magic square vertically, horizontally, and diagonally (left to right and right to left).  
If we sum up the possibilities, we will find out that there are only 8 magic square matrices.

Here's a breakdown:

- Original Square
- 3 Rotations
- 2 Horizontal Reflections (vertical reflection is the same as horizontal for a 3x3 square)
- 2 Diagonal Reflections 

So the first step is to define all possibilities, so that way we can compare the given matrix with each magic square variation to see which is the closest to the given matrix.

So, starting with the magic square given by the problem description, we can come up with the following function

```golang
func generateMagicSquares() [8][][]int32 {
    magicSquares := [8][][]int32{
       { {8, 3, 4}, {1, 5, 9}, {6, 7, 2} },
       { {4, 3, 8}, {9, 5, 1}, {2, 7, 6} },
       { {6, 7, 2}, {1, 5, 9}, {8, 3, 4} },
       { {2, 7, 6}, {9, 5, 1}, {4, 3, 8} },
       { {6, 1, 8}, {7, 5, 3}, {2, 9, 4} },
       { {8, 1, 6}, {3, 5, 7}, {4, 9, 2} },
       { {4, 9, 2}, {3, 5, 7}, {8, 1, 6} },
       { {2, 9, 4}, {7, 5, 3}, {6, 1, 8} },
    }
    return magicSquares
}
```

Now that we have all the possibilities, we can create a function to compare a matrix with a magic square and return the absolute cost to change each item of the matrix with the magic square item in the same line and column.

```golang
func abs(num int32) int32 {
    if num < 0 {
        return - num
    }
    
    return num
}

func compareMatrices(m1, m2 [][]int32) int32 {
    cost := int32(0)
    
    for i := range m1 {
        for i2 := range m1 {
            cost += abs(m1[i][i2] - m2[i][i2])
        }
    }
    
    return cost
}
```

Finally, we can grab the result of the `compareMatrices` function for each magic square generated by our `generateMagicSquares` function and compare which cost is the minimal one.

```golang
func formingMagicSquare(s [][]int32) int32 {
    magicSquares := generateMagicSquares()
    minimalCost := int32(1000)
    
    for _, ms := range magicSquares {
        cost := compareMatrices(ms, s)
        if cost < minimalCost {
            minimalCost = cost
        }
    }
    
    return minimalCost
}
```

Done!

 



We define a magic square to be an n × m matrix of distinct positive integers from 1 to n^2 where the sum of any row, column, or diagonal of length n is always equal to the same number

🧊 Forming a Magic Square

## I decided that I wanted to do the next step in my career, and to do so I must stop thinking about engineering and start solving algorithm problems

Unfortunately, only knowing how to build applications, how to code in a clean way, how to apply architectural patterns such as Clean Architecture, and how to implement interfaces of communication between web applications such as REST, GraphQL, and gRPC — *honestly, I could point out hundreds of things that I have learned so far throughout my career as a developer* — is not enough to get a job in big techs.

That’s because we have to deal with the fact that we have to face live codings that will require us to solve algorithm challenges that probably you will never be required to know how to solve on a daily basis as a software developer — *and if you eventually are required, you could ask chatGPT*.

Regardless of my vent, to be honest, I love being a software developer, and even though have to step back, I am eager to come back to level one to learn fundamental concepts, such as graphs, trees, sorting algorithms, and so on.

In parallel, every single day I’ll try to resolve code challenges in the Hackerrank platform and I’ll try to document the whole process over here.

I hope to be back after those 100 days of solving code challenges and studying computing science fundamentals to give good news.



 I decided that I wanted to do the next step in my career, and to do so I must stop thinking about engineering and start solving algorithm problems