Pular para o conteúdo principal

victorstein.dev

7/100 Dias de Golang - Prática

Table of Contents

# Prática

Vamos praticar os conceitos que aprendemos até agora, com alguns exercícios de LeetCode. As soluções desses problemas não são as ótimas, elas estão aqui mais com o intuito de praticar a sintaxe da linguagem Go e as estruturas.

# 9. Palindrome Number

Dado um número inteiro x, retornar true se x é um palíndromo inteiro. Link para o problema: LeetCode - 9

x := 121

// Converte o número para string
number_as_string := strconv.Itoa(x)

// Pegamos o tamanho da string
length := len(number_as_string)

// Fazemos um for para percorrer a string, mas somente até a metade
for i := 0; i < length/2; i++ {
    // Pegamos o caracter da posição i
    left := number_as_string[i]

    // Pegamos o caracter da posição length - i - 1
    // length - i - 1 é a posição do caracter oposto ao da posição i
    // Exemplo: se i for 0, então length - i - 1 será o último caracter
    // Lembre que o índice começa em 0, então o último caracter é length - 1
    right := number_as_string[length-i-1]

    // Se os caracteres forem diferentes, então não é um palíndromo
    if left != right {
        println("Não é um palíndromo")
    }
}

println("É um palíndromo")

Nesse código, a mensagem “É um palíndromo” sempre será impressa, pois o código não faz nada quando os caracteres são diferentes. No leetcode iremos retornar um valor booleano, ao invés de imprimir uma mensagem. O legal do LeetCode é que mostra o tempo de execução e o uso de memória da sua solução e compara com outras soluções.

Resultado do LeetCode 9

# 13. Roman to Integer

Dado um número romano, retornar o valor inteiro correspondente.

Link para o problema: LeetCode - 13

x := "IX"

	// Aqui vou criar um map, que nada mais que é uma lista de chave e valor
	// Onde a chave é o caracter romano e o valor é o número correspondente
	// Veja que o tipo da chave é rune e o valor é int
	// Poderia usar string para a chave, mas como aprendi sobre rune, resolvi usar
	romanMap := map[rune]int{
		'I': 1, 'V': 5, 'X': 10, 'L': 50,
		'C': 100, 'D': 500, 'M': 1000,
	}

	// Vou duas variáveis auxiliares,
	// total que vai ser o valor total do número romano
	// prev que vai ser o valor anterior
	total := 0
	prev := 0

	// Vou percorrer cada caracter do número romano
	// Veja que esse for é um pouco diferente do for do exemplo 9
	// faço o uso do range, que é uma função que retorna dois valores
	// O primeiro é o índice e o segundo é o caracter
	// Mas como não vou usar o índice, coloquei _ para ignorar
	for _, value := range x {

		// Aqui vou pegar o valor do caracter atual
		// Veja que uso o map para pegar o valor
		curr := romanMap[value]

		// Se o valor atual for maior que o valor anterior
		// Então quer dizer que o número é composto por dois caracteres
		// Exemplo: IV, IX, XL, XC, CD, CM
		// Então para calcular o valor total, preciso subtrair o valor anterior
		// Mas como o valor anterior já foi somado, preciso subtrair duas vezes
		if curr > prev {
			total += curr - 2*prev
		} else {

			// Se o valor atual não for maior que o valor anterior
			// Então é um número normal
			total += curr
		}
		prev = curr
	}

	fmt.Println(total)

Nesse caso, deveriamos retornar o valor no lugar do fmt.Println(total). Veja que nesse caso usamos 4,71 MB de memória e o tempo de execução foi de 0 ms.

Resultado do LeetCode 13