Recursão em java

Boa noite, estou com uma questão da faculdade para fazer no site do Hackerrank e estou com dificuldade, ela solicita que substitua todas as vezes que aparecer “pi” na string por “3.14” apenas utilizando recursividade, sem loops while ou for. alguém consegue me dar uma luz? vou mandar o código base que o professor deixou na plataforma do hackerrank.

import <a href="http://java.io" rel="noopener nofollow ugc">java.io</a>.<em>;

import java.math.</em>;

import java.security.<em>;

import java.text.</em>;

import java.util.<em>;

import java.util.concurrent.</em>;

import java.util.function.<em>;

import java.util.regex.</em>;

import java.util.stream.*;

import static java.util.stream.Collectors.joining;

import static java.util.stream.Collectors.toList;

class Result {

/*
 * Complete the 'novaString' function below.
 *
 * The function is expected to return a STRING.
 * The function accepts STRING string as parameter.
 */

public static String novaString(String string) {
// Write your code here

}

}

public class Solution {

public static void main(String[] args) throws IOException {

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv(“OUTPUT_PATH”)));

String string = bufferedReader.readLine();

    String result = Result.novaString(string);

    bufferedWriter.write(result);
    bufferedWriter.newLine();

    bufferedReader.close();
    bufferedWriter.close();
}

}

Primeiramente, aprenda a postar código. Todo o seu código deve ser formatado. Agora, meu Deus, que professor é esse com esse template hein? Além disso, o problema está mal especificado. Afinal, é só realizar a substituição, uma por vez, a cada chamada recursiva? Quais métodos da classe String podem ser usados e/ou quais não podem ser usados? A ideia é fazer vocês “sofrerem” e implementar tudo na mão ou pode usar, por exemplo, o método replaceFirst() para substituir a primeira ocorrência? Péssimo exemplo de uso de recursão também…

public static void main( String[] args ) {

    String[] testes = {
        "jkashdjkahdjahdjsakjdkjsahd",
        "jkashdjkaspijaklsdjkahdjk3ajshdjkasdhdkjaspiaskjhdjkashd",
        "pipipipipipipipipipipipipipipipipipipi"
    };

    for ( String t : testes ) {
        System.out.println( t + " -> " + novaString( t ) );
    }

}

public static String novaString( String string ) {

    // a recursão ocorre quando existe uma substring "pi" dentro
    // da string que está sendo processada
    if ( string.contains( "pi" ) ) {

        // se há "pi", substitui a primeira ocorrência por 3.14 e 
        // passa a nova string para uma nova chamada de novaString
        return novaString( string.replaceFirst( "pi", "3.14" ) );
    }

    // a base da recursão é alcançada quando não existem mais substrings
    // "pi" na string
    return string;

}

Se não puder usar replaceFirst() ai vc teria que implementar seu método de substituição manualmente. Se eu não errei nada, ficaria algo assim. Só usei o método toCharArray() de String, mas poderia fazer sem tbm, consultando cada caractere com o método charAt(). Daria para melhorar muito o código abaixo, mesmo não usando métodos da classe String, mas preferi deixar assim pra ficar mais fácil de entender.

public static void main( String[] args ) {

    String[] testes = {
        "jkashdjkahdjahdjsakjdkjsahd",
        "jkashdjkaspijaklsdjkahdjk3ajshdjkasdhdkjaspiaskjhdjkashd",
        "ppppppppppipipipipipipipipipi"
    };

    for ( String t : testes ) {
        System.out.println( t + " -> " + novaString( t ) );
    }

}

public static String novaString( String string ) {

    // a recursão ocorre quando existe uma substring "pi" dentro
    // da string que está sendo processada
    if ( primeiroIndice( string, "pi" ) != -1 ) {

        // se há "pi", substitui a primeira ocorrência por 3.14 e 
        // passa a nova string para uma nova chamada de novaString
        return novaString( substituirPrimeiraOcorrencia( string, "pi", "3.14") );
    }

    // a base da recursão é alcançada quando não existem mais substrings
    // "pi" na string
    return string;

}

private static String substituirPrimeiraOcorrencia( String base, String buscarPor, String substituirPor ) {

    char[] cBase = base.toCharArray();
    char[] cBuscarPor = buscarPor.toCharArray();
    int posicao = -1;

    // só faz sentido executar a busca se o tamanho da string buscada
    // for menor ou igual ao da string em que haverá a busca
    if ( cBase.length >= cBuscarPor.length ) {

        posicao = primeiroIndice( base, buscarPor );

        // encontrou
        if ( posicao != -1 ) {

            // agora tem que fazer o substring na mão tbm
            // o código abaixo pode ser BASTANTE resumido, fiz assim
            // para ficar mais "didático"
            char[] prefixo = new char[posicao];
            char[] sufixo = new char[cBase.length-posicao-cBuscarPor.length];

            int cPrefixo = 0;
            int cSufixo = 0;
            for ( int i = 0; i < cBase.length; i++ ) {
                if ( i < posicao ) {
                    prefixo[cPrefixo++] = cBase[i];
                }
                if ( i > posicao + cBuscarPor.length - 1 ) {
                    sufixo[cSufixo++] = cBase[i];
                }
            }

            // o ideal seria usar um StringBuilder.
            String stringComSubstituicao = "";

            for ( int i = 0; i < prefixo.length; i++ ) {
                stringComSubstituicao += prefixo[i];
            }

            stringComSubstituicao += substituirPor;

            for ( int i = 0; i < sufixo.length; i++ ) {
                stringComSubstituicao += sufixo[i];
            }

            return stringComSubstituicao;

        }

    }

    return base;

}

private static int primeiroIndice( String base, String buscarPor ) {

    char[] cBase = base.toCharArray();
    char[] cBuscarPor = buscarPor.toCharArray();

    if ( cBase.length >= cBuscarPor.length ) {

        for ( int i = 0; i < cBase.length - cBuscarPor.length + 1; i++ ) {

            boolean encontrou = true;

            for ( int j = 0; j < cBuscarPor.length; j++ ) {
                if ( cBuscarPor[j] != cBase[i+j] ) {
                    encontrou = false;
                    break;
                }
            }

            if ( encontrou ) {
                return i;
            }

        }
    }

    return -1;

}

1 Resposta

Topicos relacionados