Tag: parser

O texto e valores do enunciado em inglês foram ligeiramente alterados para diminuir a chance da solução seja encontrada por alguém que esteja fazendo a prova:

Write a function that, given an integer N, returns the maximum possible value obtainable by deleting one ‘3’ digit from the decimal representation of N.

Examples: Given N = 13938, the function should return 1938.  Given N = -3839, the function should return -389. Given N = -30, the function should return 0. After deleting the ‘3’, the only digits in the number are zeroes, so its value is 0.

Assume that:

• • N is an integer within the range -99999999 to 99999999;
  • N contains at least one ‘3’ digit in its decimal representation;
  • N consists of at least two digits in its decimal representation.

In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.

Enunciado (resumido) em português

Dado um número inteiro N, retorne o maior valor possível ao remover o dígito 3 do número. Por exemplo: dado N= 393, deve retornar 93. Se N = 3153, retorna 315. Se N= -323, retorna -23. Por fim, se N = -30, retorna 0 (zero).

Assuma que sempre haverá um 3 no valor informado e este valor sempre terá pelo menos duas casas decimais.

Apesar de receber um número inteiro, trata-se de uma questão de parse de strings, uma vez que o valor precisa ser convertido para string para ser alterado (é possível trabalhar apenas com números, mas isto torna a questão muito mais complexa).

Para resolver o problema vamos pegar o valor 3153. Se remover o primeiro “3”, retorna 153, se remover o segundo 315, que é a resposta esperada.

Uma das formas de resolver o problema é identificar as posições da string que possuem o 3 e depois eliminar estas posições (indexes) uma a uma, comparando o resultado, o que gera o seguinte algoritmo em português estruturado

1. Converta o número para string
2. Percora a string identificando as posições onde o valor = 3
3. Armaze as posições num vetor 
4. Inicialize uma variável maiorValor com o menor valor possível
5. Para cada uma das posições do vetor faça
   6. Remova o caracter da posição na string original
   7. Compara o valor de maiorValor com o novo valor gerado
   8. Se o novo valor for maior, armaze no valor em maiorValor
9. Fim do para
10. Retorne o maior valor

A solução em C#

using System;
using System.Collections.Generic;

class Solution {
    //retorna um vetor com as posicoes da string "number" 
    //ocupadas pelo numero 3
    //ex: 635131 retorna [1,4] => a contagem comeca em 0
    private static List<int> GetIndexes(string number) {
        //cria uma lista (que sera retornada)
        var indexes = new List<int>();

        //percore todos os caracteres da string
        //number.Length = 6, para o numero 635131 
        for(int i = 0; i< number.Length; i++) {
            //se caracter = 3, adiciona o indice na lista
            if (number[i] == '3') {
                indexes.Add(i);
            }
        }
        return indexes;
    }

    public int solution(int N) {
        //conver o numero N para uma string
        var originalNumber = N.ToString();
        //pega a lista de indices
        var indexes = GetIndexes(originalNumber);
        //seta o maior valor como o menor inteiro existe
        //assim qualquer valor gerado serah maior q ele
        var maxValue = int.MinValue;

        //percore todos os elementos do vetor
        foreach(var index in indexes) {
           //remove o caracter da posicao armazenada em GetIndexes()
            var number = originalNumber.Remove(index,1);
            //transforma a string num numero inteiro
            var newNumber = int.Parse(number);

            //se o "valor maximo" for menor que o "novo valor"
            //seta o "valor maximo" como sendo o "novo valor"
            if (maxValue < newNumber) {
                maxValue = newNumber;
            }
        }
        return maxValue;
    }
}

 

Origem da questão
País: Irlanda	Tipo: Teste de Código	Assunto: manipulação de strings
Ramo de negócio da empresa: Pagamentos		Grau de Dificuldade: Fácil