Estou desenvolvendo o projeto Open Source Megusta vai facilitar a vida do Programador! União das linguagens de programação Java, Javascript, PHP, Python, Clipper, Rust, C/C++, ASSEMBLY e WebAssembly. Queria a sua opini…

Megusta (União de várias linguagens)

20 de fevereiro de 2026 35 respostas

JorgeLuizGSousa 20 de fevereiro de 2026

35 Respostas

JorgeLuizGSousa 20 de fev. de 2026

Resultado:

import java.util.ArrayList;
import java.util.List;

import Megusta.Megusta;
public class xMain {
     public static void main(String[] args) {
        Megusta r = new Megusta();
        r.rPrint("Esta eh uma mensagem de exemplo.");

        r.rPrintln("Esta eh uma mensagem de exemplo.");

        r.rPrintln();

        String nome = r.rInput("Qual eh o seu nome? ");
        r.rPrintln("Olah, " + nome + "!");

        System.out.println();

        String conteudo = "Este eh o conteudo que serah salvo no arquivo.";
        String nomeArquivo = "meu_arquivo.txt";
        r.rSaveFile(nomeArquivo, conteudo);

        System.out.println();

        System.out.println(r.rOpenFile(nomeArquivo));

        System.out.println();
        r.rOpenProgram("c:/java/jdk-23/bin/java.exe -jar /MeuApp/WindowJAR.jar");

        // strReplace
        String original = "Hoje é um lindo dia!";
        String substituida = r.strReplace(original, "lindo", "maravilhoso");
        System.out.println(substituida); // Saída: "Hoje é um maravilhoso dia!"

        // strLength
        String minhaString = "Olá, mundo!";
        int tamanho = r.strLength(minhaString);
        System.out.println("O tamanho da string é: " + tamanho); // Saída: "O tamanho da string é: 12"
 
        // strSubstring
        String original2 = "Isso é uma String de exemplo.";
        String sub = r.strSubstring(original2, 8, 13);
        System.out.println(sub); // Saída: "uma S"

        // strCharAt
        String minhaString2 = "Olá, mundo!";
        char primeiroCaractere = r.strCharAt(minhaString2,0); // Obtém o primeiro caractere 'O'
        char quartoCaractere = r.strCharAt(minhaString2, 3); // Obtém o quarto caractere ','

        System.out.println("Primeiro caractere: " + primeiroCaractere);
        System.out.println("Quarto caractere: " + quartoCaractere);

        // strIndexOf
        String minhaString3 = "Isso é um exemplo de indexOf em Java.";
        int indice = r.strIndexOf(minhaString3, "exemplo");
        System.out.println("A substring 'exemplo' começa no índice: " + indice); // Saída: "A substring 'exemplo' começa no índice: 13"

        // strLastIndexOf
        String minhaString4 = "Isso é um exemplo de lastIndexOf em Java. lastIndexOf é útil para encontrar a última ocorrência de uma substring.";
        int indice2 = r.strLastIndexOf(minhaString4,"lastIndexOf");
        System.out.println("A última ocorrência de 'lastIndexOf' começa no índice: " + indice2); // Saída: "A última ocorrência de 'lastIndexOf' começa no índice: 38"
 
        // strToLowerCase
        String minhaString5 = "Isso É Uma String De Exemplo.";
        String emMinusculas = r.strToLowerCase(minhaString5);
        System.out.println(emMinusculas); // Saída: "isso é uma string de exemplo."

        // strToUpperCase
        String minhaString6 = "Isso É Uma String De Exemplo.";
        String emMaiusculas = r.strToUpperCase(minhaString6);
        System.out.println(emMaiusculas); // Saída: "ISSO É UMA STRING DE EXEMPLO."
 
        // strCompareTo
        String string1 = "abacate";
        String string2 = "banana";

        int resultado = r.strCompareTo(string1, string2);

        if (resultado < 0) {
                System.out.println("string1 é menor que string2");
        } else if (resultado == 0) {
                System.out.println("string1 é igual a string2");
        } else {
                System.out.println("string1 é maior que string2");
        }

        // strCompareToIgnoreCase
        String string1_1 = "maçã";
        String string2_1 = "MaÇÃ";

        int resultado2 = r.strCompareToIgnoreCase(string1_1, string2_1);

        if (resultado2 < 0) {
                System.out.println("string1 é menor que string2 (ignorando a diferença entre maiúsculas e minúsculas)");
        } else if (resultado2 == 0) {
                System.out.println("string1 é igual a string2 (ignorando a diferença entre maiúsculas e minúsculas)");
        } else {
                System.out.println("string1 é maior que string2 (ignorando a diferença entre maiúsculas e minúsculas)");
        }

        // strEquals
        String string1_2 = "Olá, mundo!";
        String string2_2 = "Olá, mundo!";
        String string3_2 = "olá, Mundo!";

        boolean saoIguais1 = r.strEquals(string1_2, string2_2); // Retorna true
        boolean saoIguais2 = r.strEquals(string1_2, string3_2); // Retorna false

        System.out.println(saoIguais1);
        System.out.println(saoIguais2);
 
        // strEqualsIgnoreCase
        String string1_3 = "Olá, mundo!";
        String string2_3 = "olá, Mundo!";

        boolean saoIguais = r.strEqualsIgnoreCase(string1_3, string2_3); // Retorna true

        System.out.println(saoIguais);


        System.out.println();

        String Texto;
        Texto = "";

        int Dia_do_mes = r.dateDay();
        int Dia_da_semana = r.dateWeekDay();
        int Mes = r.dateMouth();
        int Ano = r.dateYear();

        // ---------------------------------------
        int Horas = r.dateHour24();
        int Minutos = r.dateMinute();
        int Segundos = r.dateSecond();
        // ---------------------------------------
        String semana[];
        semana = new String[8];
        semana[0] = "";
        semana[1] = "Domingo";
        semana[2] = "Segunda";
        semana[3] = "Terça";
        semana[4] = "Quarta";
        semana[5] = "Quinta";
        semana[6] = "Sexta";
        semana[7] = "Sabado";
        String Semana_atual = semana[Dia_da_semana];
        //-------------------------
        String Mes2[];
        Mes2 = new String[12];
        Mes2[0] = "Janeiro";
        Mes2[1] = "Fevereiro";
        Mes2[2] = "Março";
        Mes2[3] = "Abril";
        Mes2[4] = "Maio";
        Mes2[5] = "Junho";
        Mes2[6] = "Julho";
        Mes2[7] = "Agosto";
        Mes2[8] = "Setembro";
        Mes2[9] = "Outubro";
        Mes2[10] = "Novembro";
        Mes2[11] = "Desembro";
        String Mes_atual = Mes2[Mes];
        Texto += Semana_atual + ", " + Dia_do_mes + " de " + Mes_atual + " de " + Ano;
        Texto += "\n";
        Texto += "São: " + Horas + " horas, " + Minutos + " minutos e " + Segundos + " segundos.";

        System.out.println(Texto);

        Texto = "";

        int x_dia = 28;
        int x_mes = 4;
        int x_ano = 1997;
        
        // ---------------------------------------
        Dia_do_mes = x_dia;
        Dia_da_semana = r.dateSetWeekDay(x_ano, x_mes, x_dia);
        Mes = x_mes;
        Ano = x_ano;

        semana[0] = "";
        semana[1] = "Domingo";
        semana[2] = "Segunda";
        semana[3] = "Terça";
        semana[4] = "Quarta";
        semana[5] = "Quinta";
        semana[6] = "Sexta";
        semana[7] = "Sabado";
        Semana_atual = semana[Dia_da_semana];
        //-------------------------
        Mes2[0] = "Janeiro";
        Mes2[1] = "Fevereiro";
        Mes2[2] = "Março";
        Mes2[3] = "Abril";
        Mes2[4] = "Maio";
        Mes2[5] = "Junho";
        Mes2[6] = "Julho";
        Mes2[7] = "Agosto";
        Mes2[8] = "Setembro";
        Mes2[9] = "Outubro";
        Mes2[10] = "Novembro";
        Mes2[11] = "Desembro";
        Mes_atual = Mes2[Mes];
        Texto += Semana_atual + ", " + Dia_do_mes + " de " + Mes_atual + " de " + Ano;

        System.out.println(Texto);

        System.out.println();

        //ArrayList
        //arrAllAdd(Object o): adiciona à coleção o objeto passado como argumento.

        List<String> frutasx = new ArrayList<>();

        // adiciona itens na lista
        r.arrAddAll(frutasx, "Banana", "Melão", "Goiaba", "Morango");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutasx); i++){
                System.out.println(r.arrGet(frutasx, i));
        }

        System.out.println();

        //add(Object o): adiciona à coleção o objeto passado como argumento.
        //size(): retorna o tamanho da coleção
        //get(int index): retorna um objeto dada uma posição.

        List<String> frutas1 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas1, "Banana");
        r.arrAdd(frutas1, "Melão");
        r.arrAdd(frutas1, "Goiaba");
        r.arrAdd(frutas1, "Morango");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas1); i++){
                System.out.println(r.arrGet(frutas1, i));
        }

        System.out.println();

        //add(int index, Object element): adiciona um objeto dada uma posição.

        List<String> frutas2 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas2, "Banana");
        r.arrAdd(frutas2, "Melão");
        r.arrAdd(frutas2, "Goiaba");
        r.arrAdd(frutas2, "Morango");

        r.arrAdd(frutas2, 1, "======");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas2); i++){
                System.out.println(r.arrGet(frutas2, i));
        }

        System.out.println();

        //set(int index, Object element): edita um objeto dada uma posição.

        List<String> frutas3 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas3, "Banana");
        r.arrAdd(frutas3, "Melão");
        r.arrAdd(frutas3, "Goiaba");
        r.arrAdd(frutas3, "Morango");

        r.arrSet(frutas3, 1, "======");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas3); i++){
                System.out.println(r.arrGet(frutas3, i));
        }

        System.out.println();

        //remove(int index): remove um objeto dada sua posição.

        List<String> frutas4 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas4, "Banana");
        r.arrAdd(frutas4, "Melão");
        r.arrAdd(frutas4, "Goiaba");
        r.arrAdd(frutas4, "Morango");

        r.arrRemove(frutas4, 1);

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas4); i++){
                System.out.println(r.arrGet(frutas4, i));
        }

        System.out.println();

        //clear(): apaga todo o conteúdo da coleção.

        List<String> frutas5 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas5, "Banana");
        r.arrAdd(frutas5, "Melão");
        r.arrAdd(frutas5, "Goiaba");
        r.arrAdd(frutas5, "Morango");

        r.arrClear(frutas5);

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas5); i++){
                System.out.println(r.arrGet(frutas5, i));
        }

        System.out.println();

        //boolean contains(Object o): verifica se o objeto passado como argumento existe na coleção.

        List<String> lista1 = new ArrayList<>();
        r.arrAdd(lista1, "Jose");
        r.arrAdd(lista1, "Maria");
        System.out.println(r.arrContains(lista1, "Jose")); // True

        System.out.println();

        //Object[ ] toArray(): converte os elementos da coleção em um array (rápidos acesso aos elementos).

        List<String> lista2 = new ArrayList<>();
        r.arrAdd(lista2, "Jose");
        r.arrAdd(lista2, "Maria");
        r.arrAdd(lista2, "Joao");
        Object[] elementos2 = r.arrToArray(lista2);
        for(int i=0; i<r.xArrLength(elementos2);i++) {
                System.out.println(elementos2[i]);
        }

        System.out.println();

        //int indexOf (Object o): retorna a posição de um objeto.

        List<String> lista3 = new ArrayList<>();
        r.arrAdd(lista3, "Jose");
        r.arrAdd(lista3, "Maria");
        r.arrAdd(lista3, "João");
        System.out.println(r.arrIndexOf(lista3, "Maria")); //1

        System.out.println();

        //int lastIndexOf (Object o): retorna o último índice de um objeto.

        List<String> lista4 = new ArrayList<>();
        r.arrAdd(lista4, "Jose");
        r.arrAdd(lista4, "Maria");
        r.arrAdd(lista4, "João");
        r.arrAdd(lista4, "Maria");
        System.out.println(r.arrLastIndexOf(lista4, "Maria")); //3

        System.out.println();

//Funções Matemáticas

//Convertendo String para Numérica
//Números Inteiros
//mathint
        // Exemplo simples
        String numeroString = "123456";
        long numeroLong = r.mathInt(numeroString);
        System.out.println("Número convertido: " + numeroLong);

        // Tratamento de exceção para entrada inválida
        String entradaInvalida = "abc";
        try {
            long resultadoL = r.mathInt(entradaInvalida);
            System.out.println("Número convertido: " + resultadoL);
        } catch (NumberFormatException e) {
            System.out.println("Erro: A string não é um número válido.");
        }

//Números Reais
//mathnum
        // Exemplo simples
        numeroString = "123.456";
        double numeroDoubleD = r.mathNum(numeroString);
        System.out.println("Número convertido: " + numeroDoubleD);

        // Tratamento de exceção para entrada inválida
        entradaInvalida = "abc";
        try {
            double resultadoD = r.mathNum(entradaInvalida);
            System.out.println("Número convertido: " + resultadoD);
        } catch (NumberFormatException e) {
            System.out.println("Erro: A string não é um número válido.");
        }

//Boleanos
//mathbool
        // Exemplos simples
        String trueString = "true";
        boolean booleanTrue = r.mathBool(trueString);
        System.out.println("Valor booleano: " + booleanTrue);

        String falseString = "false";
        boolean booleanFalse = r.mathBool(falseString);
        System.out.println("Valor booleano: " + booleanFalse);

        // Tratamento de entrada inválida
        entradaInvalida = "abc";
        boolean resultadoB = r.mathBool(entradaInvalida);
        System.out.println("Valor booleano: " + resultadoB);
        // Como "abc" não é "true", o resultado será false
//Arredondando valores
//Math.floor
        double numeroOriginal = 0.0;
        double numeroArredondado = 0.0;

        numeroOriginal = 7.8;
        numeroArredondado = r.mathFloor(numeroOriginal);

        System.out.println("Número original: " + numeroOriginal);
        System.out.println("Número arredondado para baixo: " + numeroArredondado);
//Math.ceil
        numeroOriginal = 7.2;
        numeroArredondado = r.mathCeil(numeroOriginal);

        System.out.println("Número original: " + numeroOriginal);
        System.out.println("Número arredondado para cima: " + numeroArredondado);
//Math.round
        numeroOriginal = 7.5;
        numeroArredondado = r.mathRound(numeroOriginal);

        System.out.println("Número original: " + numeroOriginal);
        System.out.println("Número arredondado: " + numeroArredondado);

//Digite um número com 3 casas decimais
//mathDecimalFormat
        double numero = 0.0;
        numero = 123.456789;

        String numeroFormatado = r.mathDecimalFormat(numero, "#.###");

        System.out.println(numeroFormatado);

//Formatar moeda
//mathNumberFormat
        numero = 1234567.89;

        // Formatar o número de acordo com a localidade do Brasil
        String numeroFormatadoBrasil = r.mathNumberFormat(numero, "pt","BR");
       
        System.out.println("Brasil: " + numeroFormatadoBrasil);

//Funções matemáticas comuns
//Math.random

        // Gerar um número aleatório no intervalo [0.0, 1.0)
        double numeroAleatorio = r.mathRandom();

        System.out.println("Número aleatório: " + numeroAleatorio);

        //double numeroAleatorioNoIntervalo = Math.random() * (max - min) + min;
        //double numeroAleatorioIntervalo = Math.random() * (10.0 - 5.0) + 5.0;
        //System.out.println("Número aleatório no intervalo: " + numeroAleatorioIntervalo);
//Math.abs

        int numeroInteiro = -5;
        long numeroLongo = -123456789L;
        float numeroFloat = -3.14f;
        double numeroDouble = -2.71828;

        // Calcular o valor absoluto para diferentes tipos de números
        int absInt = (int) r.mathAbs(numeroInteiro);
        long absLong = (long) r.mathAbs(numeroLongo);
        float absFloat = (float) r.mathAbs(numeroFloat);
        double absDouble = r.mathAbs(numeroDouble);

        System.out.println("Valor absoluto de " + numeroInteiro + " = " + absInt);
        System.out.println("Valor absoluto de " + numeroLongo + " = " + absLong);
        System.out.println("Valor absoluto de " + numeroFloat + " = " + absFloat);
        System.out.println("Valor absoluto de " + numeroDouble + " = " + absDouble);

//Math.max

        double numero3 = 15.5;
        double numero4 = 12.3;

        // Encontrar o máximo entre dois números de ponto flutuante
        double maximoDouble = r.mathMax(numero3, numero4);
        System.out.println("Máximo entre " + numero3 + " e " + numero4 + " = " + maximoDouble);

        // int maximoEntreTres = Math.max(Math.max(numero1, numero2), numero3);
//Math.min

        numero3 = 15.5;
        numero4 = 12.3;

        // Encontrar o mínimo entre dois números de ponto flutuante
        double minimoDouble = r.mathMin(numero3, numero4);
        System.out.println("Mínimo entre " + numero3 + " e " + numero4 + " = " + minimoDouble);

       //int minimoEntreTres = Math.min(Math.min(numero1, numero2), numero3);

//Math.max

        // Encontrar o máximo entre dois números de ponto flutuante
        maximoDouble = r.mathMaxArr(15.5, 12.3, 10.8, 14.6);
        System.out.println("Máximo entre 15.5, 12.3, 10.8, 14.6 = " + maximoDouble);

//Math.min

        // Encontrar o mínimo entre dois números de ponto flutuante
        minimoDouble = r.mathMinArr(15.5, 12.3, 10.8, 14.6);
        System.out.println("Mínimo entre 15.5, 12.3, 10.8, 14.6 = " + minimoDouble);

//Math.pow
        double base = 2.0;
        double expoente = 3.0;

        // Calcular 2^3
        resultado = (int) r.mathPow(base, expoente);
        System.out.println("Resultado: " + resultado);

//Math.sqrt
        numero = 25.0;

        // Calcular a raiz quadrada de 25
        double raizQuadrada = r.mathSqrt(numero);

        System.out.println("Raiz quadrada de " + numero + " = " + raizQuadrada);

//Math.SQRT1_2
        // Utilizando a constante Math.SQRT1_2

        //double mathSQRT1_2 = 0.7071067811865476;
        
        double raizQuadradaDeUmMeio = r.mathSQRT1_2;

        System.out.println("Raiz quadrada de 1/2: " + raizQuadradaDeUmMeio);

//Math.SQRT2
        // Utilizando a constante Math.SQRT2

        //double mathSQRT2 = 1.4142135623730951;

        double raizQuadradaDeDois = r.mathSQRT2;

        System.out.println("Raiz quadrada de 2: " + raizQuadradaDeDois);

 
//Math.cbrt
        numero = 27.0;

        // Calcular a raiz cúbica de 27
        double raizCubica = r.mathCbrt(numero);

        System.out.println("Raiz cúbica de " + numero + " = " + raizCubica);

//Math.sign
        numero = -5.5;

        // Obtendo o sinal do número
        int sinal = (int) r.mathSignum(numero);

        System.out.println("Sinal de " + numero + " = " + sinal);

        System.out.println();

//Funções trigonométricas
//Math.PI
        // Acesso à constante Math.PI
        double pi = r.mathPI;

        // Exibindo o valor de pi
        System.out.println("O valor de pi é: " + pi);

        // Exemplo de cálculo usando pi
        double raio = 5.0;
        double area = pi * raio * raio;
        System.out.println("A área de um círculo com raio " + raio + " é: " + area);
/*
function radianos(){
return Math.PI/180
}
*/

        double graus = 45.0;
        double radianos = r.mathConvertToRadians(graus);

        System.out.println(graus + " graus é equivalente a " + radianos + " radianos.");
 
//Math.sin
        // Ângulo em radianos
        double anguloEmRadianos = Math.PI / 4.0;

        // Calculando o seno do ângulo
        double senoDoAngulo = r.mathSin(anguloEmRadianos);

        // Exibindo o resultado
        System.out.println("O seno de " + anguloEmRadianos + " radianos é: " + senoDoAngulo);

//Math.cos
        // Ângulo em radianos
        anguloEmRadianos = Math.PI / 3.0;

        // Calculando o cosseno do ângulo
        double cossenoDoAngulo = r.mathCos(anguloEmRadianos);

        // Exibindo o resultado
        System.out.println("O cosseno de " + anguloEmRadianos + " radianos é: " + cossenoDoAngulo);

//Math.tan
        // Ângulo em radianos
        anguloEmRadianos = Math.PI / 6.0;

        // Calculando a tangente do ângulo
        double tangenteDoAngulo = r.mathTan(anguloEmRadianos);

        // Exibindo o resultado
        System.out.println("A tangente de " + anguloEmRadianos + " radianos é: " + tangenteDoAngulo);
 
//Math.asin
        // Valor para o qual queremos calcular o arco seno
        double valor = 0.5;

        // Calculando o arco seno do valor
        double arcoSeno = r.mathAsin(valor);

        // Exibindo o resultado em radianos
        System.out.println("O arco seno de " + valor + " é: " + arcoSeno + " radianos.");

//Math.acos
        // Valor para o qual queremos calcular o arco cosseno
        valor = 0.5;

        // Calculando o arco cosseno do valor
        double arcoCosseno = r.mathAcos(valor);

        // Exibindo o resultado em radianos
        System.out.println("O arco cosseno de " + valor + " é: " + arcoCosseno + " radianos.");

//Math.atan
        // Valor para o qual queremos calcular o arco tangente
        valor = 0.5;

        // Calculando o arco tangente do valor
        double arcoTangente = r.mathAtan(valor);

        // Exibindo o resultado em radianos
        System.out.println("O arco tangente de " + valor + " é: " + arcoTangente + " radianos.");
 
//Math.sinh
        // Valor para o qual queremos calcular o seno hiperbólico
        valor = 2.0;

        // Calculando o seno hiperbólico do valor
        double senoHiperbolico = r.mathSinh(valor);

        // Exibindo o resultado
        System.out.println("O seno hiperbólico de " + valor + " é: " + senoHiperbolico);

//Math.cosh
        // Valor para o qual queremos calcular o cosseno hiperbólico
        valor = 2.0;

        // Calculando o cosseno hiperbólico do valor
        double cossenoHiperbolico = r.mathCosh(valor);

        // Exibindo o resultado
        System.out.println("O cosseno hiperbólico de " + valor + " é: " + cossenoHiperbolico);

//Math.tanh
        // Valor para o qual queremos calcular a tangente hiperbólica
        valor = 2.0;

        // Calculando a tangente hiperbólica do valor
        double tangenteHiperbolica = r.mathTanh(valor);

        // Exibindo o resultado
        System.out.println("A tangente hiperbólica de " + valor + " é: " + tangenteHiperbolica);
 
//Math.asinh
        // Valor para o qual queremos calcular o arco seno hiperbólico
        valor = 2.0;

        // Calculando o arco seno hiperbólico do valor
        double arcoSenoHiperbolico = r.mathAsinh(valor);

        // Exibindo o resultado
        System.out.println("O arco seno hiperbólico de " + valor + " é: " + arcoSenoHiperbolico);

        //asinh(x) = ln(x + sqrt(x^2 + 1))
//Math.acosh
        // Valor para o qual queremos calcular o arco cosseno hiperbólico
        valor = 2.0;

        // Calculando o arco cosseno hiperbólico do valor
        double arcoCossenoHiperbolico = r.mathAcosh(valor);

        // Exibindo o resultado
        System.out.println("O arco cosseno hiperbólico de " + valor + " é: " + arcoCossenoHiperbolico);

        //acosh(x) = ln(x + sqrt(x^2 - 1))
//Math.atanh
        // Valor para o qual queremos calcular o arco tangente hiperbólico
        valor = 0.5;

        // Calculando o arco tangente hiperbólico do valor
        double arcoTangenteHiperbolico = r.mathAtanh(valor);

        // Exibindo o resultado
        System.out.println("O arco tangente hiperbólico de " + valor + " é: " + arcoTangenteHiperbolico);

        //atanh(x) = 0.5 * ln((1 + x) / (1 - x))

        System.out.println();

//Logarítmos

//Math.log
        // Número para o qual queremos calcular o logaritmo natural
        numero = 10.0;

        // Calculando o logaritmo natural do número
        double logaritmoNatural = r.mathLog(numero);

        // Exibindo o resultado
        System.out.println("O logaritmo natural de " + numero + " é: " + logaritmoNatural);

//Math.log10
        // Número para o qual queremos calcular o logaritmo na base 10
        numero = 1000.0;

        // Calculando o logaritmo na base 10 do número
        double logaritmoBase10 = r.mathLog10(numero);

        // Exibindo o resultado
        System.out.println("O logaritmo na base 10 de " + numero + " é: " + logaritmoBase10);
 
//Math.E
        // Acesso à constante Math.E
        double constanteE = r.mathE;

        // Exibindo o valor da constante E
        System.out.println("O valor da constante E é: " + constanteE);
//Math.LN2
        // Acesso à constante Math.LN2
        double LN2 = r.mathLN2;

        // Exibindo o valor do logaritmo natural de 2
        System.out.println("O valor do logaritmo natural de 2 é: " + LN2);

//Math.LOG2E
        // Acesso à constante Math.LOG2E
        double LOG2E = r.mathLOG2E;

        // Exibindo o valor do logaritmo natural de base 2 de e
        System.out.println("O valor do logaritmo natural de base 2 de e é: " + LOG2E);

//Math.LN10
        // Acesso à constante Math.LN10
        double LN10 = r.mathLN10;

        // Exibindo o valor do logaritmo natural de 10
        System.out.println("O valor do logaritmo natural de 10 é: " + LN10);

//Math.LOG10E
        // Acesso à constante Math.LOG10E
        double LOG10E = r.mathLOG10E;

        // Exibindo o valor do logaritmo natural de base 10 de e
        System.out.println("O valor do logaritmo natural de base 10 de e é: " + LOG10E);
 
//Math.exp
        // Expoente para o qual queremos calcular a exponenciação
        expoente = 2.0;

        // Calculando a exponenciação de e elevado ao expoente
        double resultado3 = r.mathExp(expoente);

        // Exibindo o resultado
        System.out.println("O resultado de e elevado a " + expoente + " é: " + resultado3);

//Math.log2
        // Número para o qual queremos calcular o logaritmo de base 2
        double numero2 = 8.0;

        // Calculando o logaritmo de base 2 do número
        double LOG2 = r.mathLog2(numero2);

        // Exibindo o resultado
        System.out.println("O logaritmo de base 2 de " + numero2 + " é: " + LOG2);

        //log2(x) = ln(x) / ln(2)

//Math.log1p
        // Valor para o qual queremos calcular o logaritmo natural de 1 mais um
        valor = 0.5;

        // Calculando o logaritmo natural de 1 mais um
        double resultado4 = r.mathLog1p(valor);

        // Exibindo o resultado
        System.out.println("O logaritmo natural de 1 mais " + valor + " é: " + resultado4);
     }
}

Jonathan_Medeiros 20 de fev. de 2026

Não consegui entender o seu objetivo e o que você está buscando aqui no fórum exatamente com relação seu código…

JorgeLuizGSousa 20 de fev. de 2026

União das linguagens de programação Java, Javascript, PHP, Python, Clipper, Rust, C/C++, Assembly e WebAssembly.
A ideia é: ao trocar de linguagem de programação, algumas partes do código não mudam.
De Java para Python, algumas partes do código não mudam, assim como de PHP para Rust.

JorgeLuizGSousa 20 de fev. de 2026

É só um modelo!
Vou usar IA para programar em outras linguagens!

JorgeLuizGSousa 20 de fev. de 2026

Queria saber das pessoas que estão com dúvida no meu código. Assim vou aprimorar. Qualquer dúvida em relação ao meu código? É só falar:
– Estou com dúvida?

davidbuzatto 20 de fev. de 2026

Você poderia mostrar um exemplo em que você engloba Java, Javascript, PHP, Python, Clipper, Rust, C/C++, Assembly e WebAssembly? Na minha cabeça isso não faz o menor sentido, mas quero ver qual é sua ideia.

j-menezes 21 de fev. de 2026 1 like

Jesus Amado

JorgeLuizGSousa 21 de fev. de 2026

Insiro o seguinte comando:

megusta -javascript exemplo.mg -o exemplo.js

Irá compilar um código javascript
Igual ao TypeScript
Assim como:

Python
C
Clipper
Java
Javascript
PHP
Rust
Assembly
WebAssembly

JorgeLuizGSousa 21 de fev. de 2026

Se não entender? Pode conversar comigo? Isso ajudará a criar um código melhor!

davidbuzatto 21 de fev. de 2026 2 likes

Eu tenho a impressão que você não sabe muito bem do que está falando. Você quer criar um transpilador “universal” que em vários cenários não vai conseguir transpilar, pq uma linguagem alvo não vai ter uma ou mais funcionalidades da linguagem fonte, fazendo você ter que gerar código a mais para ter essa relação um para um, tornando o código na linguagem alvo difícil (ou praticamente impossível) de manter.

Um exemplo:

Java (linguagem fonte):

public interface A {
    public void x();
}

public class B implements A {

    private int payload;

    public B( int payload ) {
        this.payload = payload;
    }

    @Override
    public void x() {
        System.out.printf( "Payload de B: %d\n", payload );
        System.out.println( "x de B" );
    }

}

public class C implements A {

    private int payload;

    public C( int payload ) {
        this.payload = payload;
    }

    @Override
    public void x() {
        System.out.printf( "Payload de C: %d\n", payload );
        System.out.println( "x de C" );
    }

}

public class Teste {
    public static void main( String[] args ) {
        A[] as = { new B( 42 ), new C( 69 ) };
        for ( A a : as ) {
            a.x();
        }
    }
}

Para esse cenário básico de polimorfismo, teria que gerar algo assim em C (está bem simples, você vai precisar de algo MUITO mais sofisticado para abraçar todos os casos possíveis):

#include <stdlib.h>
#include <stdio.h>

typedef enum ObjType {
    OBJ_TYPE_B,
    OBJ_TYPE_C
} ObjType;

typedef struct A A;

struct A {
    void (*x)( A *a );
    void (*xSub)( void );
    void *obj;
    ObjType objType;    
};

typedef struct B {
    int payload;
} B;

typedef struct C {
    int payload;
} C;

void x( A *a );
void xB( void );
void xC( void );

void x( A *a ) {
    if ( a->objType == OBJ_TYPE_B ) {
        // se precisasse processar algum atributo de B
        B *b = (B*) a->obj;
        printf( "Payload de B: %d\n", b->payload );
    } else if ( a->objType == OBJ_TYPE_C ) {
        // se precisasse processar algum atributo de C
        C *c = (C*) a->obj;
        printf( "Payload de C: %d\n", c->payload );
    }
    a->xSub();
}

void xB( void ) {
    printf( "x de B\n" );
}

void xC( void ) {
    printf( "x de C\n" );
}

int main( void ) {

    B b = { .payload = 42 };
    C c = { .payload = 69 };

    A as[] = {
        {
            .x = x,
            .xSub = xB,
            .obj = &b,
            .objType = OBJ_TYPE_B
        }, {
            .x = x,
            .xSub = xC,
            .obj = &c,
            .objType = OBJ_TYPE_C
        },
    };

    for ( int i = 0; i < 2; i++ ) {
        as[i].x( &as[i] );
    }

    return 0;

}

E isso que estamos falando de apenas UM caso simples de apenas UMA linguagem fonte para UMA linguagem alvo. Acho que vale para vc aprender bastante coisa, mas sinceramente, na prática, sem aplicação. Ninguém vai usar algo pra tentar fazer isso. É mais fácil e menos propenso a erros um especialista nas linguagens envolvidas reescrever.

Edit: meu código em C tá errado inclusive. Um ponteiro para B ou C deveria ser passado para a função do “subtipo”, para então desempacotar o payload e usar. Não vou refazer

JorgeLuizGSousa 21 de fev. de 2026

Quase isso!
Em relação a Orientação a Objeto, só vai usar um tipo de objeto, veja o objeto abaixo!
O código Java abaixo vai ser transpilado pra C, no exemplo acima!

Lampada

Arquivo: Lampada.java

// Lampada.java

// Classe Lampada

public class Lampada {
   // atributos
   public boolean acesa;

   // metodos
   public void ligar() {
      acesa = true;
   }
   public void desligar() {
      acesa = false;
   }
}
/*
Lampada
(from default)
--------------
+ acesa boolean
--------------
+ desligar()
+ ligar()
*/

Arquivo: testando_a_lampada.java

// testando_a_lampada.java

public class testando_a_lampada {
   public static void main (String args[]){

      Lampada lamp = new Lampada();

      lamp.ligar();
      System.out.println("Lampada Criada (Acesa = " + lamp.acesa + ")");
      lamp.desligar();
      System.out.println("Lampada Criada (Acesa = " + lamp.acesa + ")");
   }
}
/*
Resultado:
Lampada Criada (Acesa = true)
Lampada Criada (Acesa = false)
*/

davidbuzatto 21 de fev. de 2026 1 like

E você acha, sinceramente, que alguém vai usar algo que o limite na linguagem fonte? Ah, vc não pode fazer assim, tem que fazer assado… Não faz sentido.

Me mostra o “correspondente” em C do que você fez em Java. Sem usar IA, faça você. Se você não entender o que está fazendo, não tem como você saber se tá certo ou errado. Não viaja.

Infelizmente você não tem noção, ou pelo menos não tentou vislumbrar, o tamanho do problema que você está tentando solucionar. Só o tamanho da biblioteca padrão do Java por exemplo é ABSURDO e você teria que cobrir tudo, ou boa parte.

JorgeLuizGSousa 21 de fev. de 2026

Dentro da Tag
<%rMgc

…

Vou colocar o meu código Megusta.
Fora da Tag, uso o código Hospedeiro
Assim fica fácil colocar mais código.

JorgeLuizGSousa 21 de fev. de 2026

O megusta só vai usar um tipo de Objeto.
Se quiser criar a mais, tem que colocar fora da Tag
<%rMg
…
%>

davidbuzatto 21 de fev. de 2026

E outra, preciso complementar. Você tá começando pelo fim. Seu primeiro problema é fazer o parse da linguagem fonte, gerando, por exemplo, uma árvore sintática abstrata, que então vai ser percorrida para gerar o código da linguagem alvo. Enfim, boa sorte. Pelo menos tentando ver pelo lado bom, TypeScript para JavaScript já ta pronto, só usar o transpilador da Microsoft.

JorgeLuizGSousa 21 de fev. de 2026

Enquanto alguém não tiver nenhuma dúvida?
Estarei aqui esplicando?
Vou usar esse tópico para criar um código melhor.

davidbuzatto 21 de fev. de 2026

Boa sorte, Jorge. De coração. Um abraço!

JorgeLuizGSousa 21 de fev. de 2026

Obrigado!
Fique com Deus!

JorgeLuizGSousa 21 de fev. de 2026

Alguém com dúvida?

Jonathan_Medeiros 21 de fev. de 2026

100% das pessoas que responderam tem dúvidas, a todo momento você fala nada com coisa nenhuma…

Os exemplos que você deu de código java não tem utilidade nenhuma no mundo real, tudo que você mostrou eu posso invocar diretamente!

O conceito de converter uma linguagem X em uma outra Y é interessante, mas da forma como você tem se expressado e demonstrado parece não ter a menor ideia do tamanho do problema e do tamanho da complexidade e limitações envolvidas…

De qualquer forma, boa sorte com sua ideia e seu projeto!

JorgeLuizGSousa 22 de fev. de 2026

Então qual é a complexidade que está falando?

JorgeLuizGSousa 22 de fev. de 2026

Dei uma atualizada no link
https://iatagancursos.github.io/Megusta/pagina-principal.html

Críticas, dúvidas e sujestões? Serão bem-vindas?

hugokotsubo 22 de fev. de 2026 1 like

Bom, pra te dar uma ideia, veja este conversor de Java para Python. Não testei, foi só o primeiro que encontrei no Google.

Dê uma olhada no código fonte, em tudo que precisa para fazer o mínimo do básico do essencial, pra começar a ter algo minimamente funcional.

E olha que é um exemplo simples, o próprio projeto admite que não é garantido que o resultado é um código Python válido, mas que “funciona pra muitos casos”.

Imagina então para fazer funcionar em todos os casos, teria que adicionar mais código ainda. Afinal, as linguagens não são iguais, existem construções de uma que não tem equivalente na outra, e muitas vezes a conversão não é óbvia, nem sempre é uma relação 1 pra 1 (troca biblioteca X por Y, por exemplo).

E isso só faz a ida, ainda teria que implementar a volta (Python para Java), que tem os mesmos problemas (coisas que Python tem mas Java não, e o equivalente nem sempre é óbvio).

E isso é só para duas linguagens. Mas vc quer fazer de qualquer linguagem para qualquer outra, e a quantidade total de conversões cresce exponencialmente para cada linguagem adicionada.

E vc ainda quer misturar linguagens com estruturas e filosofias completamente diferentes, o que torna a tarefa ainda mais complicada.

Por fim, considerando seu tópico anterior, passou a impressão de que vc não tem familiaridade com Java. E eu não faria um conversor de linguagens sem conhecer muito bem as linguagens envolvidas.

JorgeLuizGSousa 22 de fev. de 2026

Nossa!
Quero crítica construtiva! Que constrói!
Não a crítica destrutiva! Que destrói!
Não estou querendo jogar pedra! Mas até agora só estou ouvindo crítica destrutiva!

Olha o código que estou desenvolvendo em C?

#include <stdio.h>

int main(int argc, char **argv){
    //megusta -javascript exemplo.mg -o exemplo.js
    printf("%s %s %s %s \n", argv[1], argv[2], argv[3], argv[4]);
    //Megusta
    char Megusta[][20] = {"//","/*", "*/","rInt", "rNum", "rString","rBoolean","rAND","rOR", "rXOR","rNOT","rNULL", "rTrue", "rFalse", "rIf", "rThen", "rEnd", "rElseIf", "rThen", "rEnd", "rElse", "rxElse", "rEndIf","rFor", "rThen", "rEndFor", "rxFor", "rEnd", "rWhile", "rThen", "rEndWhile", "rxWhile", "rEnd", "rDo", "rDoWhile", "rEndDo", "rSwitch", "rThen", "rCase", "rxThen", "rEndSwitch", "rReturn"};
    //Python
    char Python[][20] = {"#","'''", "'''","", "", "","","and","or", "^","not","None", "True", "False", "rIf", "rThen", "rEnd", "rElseIf", "rThen", "rEnd", "rElse", "rxElse", "rEndIf","rFor", "rThen", "rEndFor", "rxFor", "rEnd", "rWhile", "rThen", "rEndWhile", "rxWhile", "rEnd", "rDo", "rDoWhile", "rEndDo", "rSwitch", "rThen", "rCase", "rxThen", "rEndSwitch", "rReturn"};
    //Clipper
    char Clipper[][20] = {"//","/*", "*/","", "", "","",".AND.",".OR.", "rXOR",".NOT.","NIL", ".T.", ".F.", "rIf", "rThen", "rEnd", "rElseIf", "rThen", "rEnd", "rElse", "rxElse", "rEndIf","rFor", "rThen", "rEndFor", "rxFor", "rEnd", "rWhile", "rThen", "rEndWhile", "rxWhile", "rEnd", "rDo", "rDoWhile", "rEndDo", "rSwitch", "rThen", "rCase", "rxThen", "rEndSwitch", "rReturn"};
    //Rust
    char Rust[][20] = {"//","/*", "*/","i64", "f64", "rString","bool","and","or", "^","not","rNULL", "true", "false", "rIf", "rThen", "rEnd", "rElseIf", "rThen", "rEnd", "rElse", "rxElse", "rEndIf","rFor", "rThen", "rEndFor", "rxFor", "rEnd", "rWhile", "rThen", "rEndWhile", "rxWhile", "rEnd", "rDo", "rDoWhile", "rEndDo", "rSwitch", "rThen", "rCase", "rxThen", "rEndSwitch", "rReturn"};
    //C
    char C[][20] = {"//","/*", "*/","int", "float", "char*","bool","&&","||", "^","!","null", "true", "false", "if(", "){", ")", "else if(", "){", ")", "}else{", "else", "}","for(", "){", "}", "for(", ")", "while(", "){", "}", "while(", ")", "do{", "} while (", ");", "switch(", "){", "case ", ":", "}", "return"};
    //Java
    char Java[][20] = {"//","/*", "*/","int", "double", "String","boolean","&&","||", "^","!","null", "true", "false", "rIf", "if(", "){", ")", "else if(", "){", ")", "}else{", "else", "}","for(", "){", "}", "for(", ")", "while(", "){", "}", "while(", ")", "do{", "} while (", ");", "switch(", "){", "case ", ":", "}", "return"};
    //TypeScript
    char TypeScript[][20] = {"//","/*", "*/","number", "number", "string","boolean","&&","||", "^","!","null", "true", "false", "if(", "){", ")", "else if(", "){", ")", "}else{", "else", "}","for(", "){", "}", "for(", ")", "while(", "){", "}", "while(", ")", "do{", "} while (", ");", "switch(", "){", "case ", ":", "}", "return"};
    //Javascript
    char Javascript[][20] = {"//","/*", "*/","", "", "","","&&","||", "^","!","null", "true", "false", "if(", "){", ")", "else if(", "){", ")", "}else{", "else", "}","for(", "){", "}", "for(", ")", "while(", "){", "}", "while(", ")", "do{", "} while (", ");", "switch(", "){", "case ", ":", "}", "return"};
    //PHP
    char PHP[][20] = {"//","/*", "*/","rInt", "rNum", "rString","rBoolean","&&","||", "^","!","null", "true", "false", "if(", "){", ")", "else if(", "){", ")", "}else{", "else", "}","for(", "){", "}", "for(", ")", "while(", "){", "}", "while(", ")", "do{", "} while (", ");", "switch(", "){", "case ", ":", "}", "return"};
    //Assembly
    char Assembly[][20] = {";", "\n%%if 0\n", "\n%%endif\n", "rInt", "rNum", "rString","rBoolean","rAND","rOR", "rXOR","rNOT","rNULL", "rTrue", "rFalse", "rIf", "rThen", "rEnd", "rElseIf", "rThen", "rEnd", "rElse", "rxElse", "rEndIf","rFor", "rThen", "rEndFor", "rxFor", "rEnd", "rWhile", "rThen", "rEndWhile", "rxWhile", "rEnd", "rDo", "rDoWhile", "rEndDo", "rSwitch", "rThen", "rCase", "rxThen", "rEndSwitch", "rReturn"};
    //WebAssembly
    char WebAssembly[][20] = {"//","/*", "*/","rInt", "rNum", "rString","rBoolean","rAND","rOR", "rXOR","rNOT","rNULL", "rTrue", "rFalse", "rIf", "rThen", "rEnd", "rElseIf", "rThen", "rEnd", "rElse", "rxElse", "rEndIf","rFor", "rThen", "rEndFor", "rxFor", "rEnd", "rWhile", "rThen", "rEndWhile", "rxWhile", "rEnd", "rDo", "rDoWhile", "rEndDo", "rSwitch", "rThen", "rCase", "rxThen", "rEndSwitch", "rReturn"};
    return 0;
}

Jonathan_Medeiros 22 de fev. de 2026

As críticas foram completamente construtivas, se você as encarou de forma diferente possivelmente seu ego tenha sido abalado!

JorgeLuizGSousa 22 de fev. de 2026

Se conhecesse eu melhor!
Você não diria isso!

JorgeLuizGSousa 22 de fev. de 2026

O pessoal vira num negativo? Vamos ser positivo?

davidbuzatto 23 de fev. de 2026 2 likes

Jorge, tente focar em alguma outra coisa. Esse seu projeto não vai servir no mundo real. Entendo sua vontade de ajudar, de criar algo inovador, mas esse projeto não tem muito para onde ir, entende? Não faz sentido você gastar uma quantidade de energia enorme em algo que vai esbarrar em barreiras quase intransponíveis. Converter programas de brinquedo de conceitos simples, que pedem uma entrada, fazer algum processamento, e geram uma saída não tem utilidade alguma entende? Enquanto é um println, um Scanner, um printf, um cout, um write ou qualquer outra coisa mais simples, ta beleza, o negócio vai servir, mas vai ser só aparecer algo mais intrincado ou específico da linguagem fonte que você vai começar a ter muito problema para tentar resolver e não vai conseguir se não for expert nas linguagens. Se seu sonho é esse mesmo e você quer perseguí-lo a qualquer custo, primeiro então diminua o escopo. Trabalhe apenas com duas linguagens, tanto no processo de traduzir A para B quanto B para A e lembre-se, você precisa cobrir TODAS as features de cada linguagem, seja do ponto de vista sintático, semântico, do(s) paradigma(s) que ela abraça e o mais difícil, da biblioteca padrão. Te garanto, você vai ter trabalho para ANOS até ter algo viável, pois é você consigo mesmo. Não deixa de viver e aprender outras coisas por causa desse projeto, afinal, por o pão na mesa, ter um teto para morar etc é mais importante que isso.

Sugiro aos colegas visitarem as redes sociais, canal do YouTube, Linkdin do Jorge para conhecer a realidade dele.

Jorge, para tirar dúvidas do seu projeto, abra outros tópicos e aguarde as respostas, tudo bem?

Boa semana a todos.

hugokotsubo 23 de fev. de 2026 1 like

Desculpe, mas pra mim crítica destrutiva é aquela que só xinga e não dá argumentos (tipo “esse projeto é um lixo”, não explica o motivo e também não ajuda em nada). Não acho que foi o caso aqui.

Eu e os demais falamos em detalhes quais são os problemas da sua ideia. No meu post acima, inclusive, eu explico porque o problema é mais difícil do que vc está imaginando. Não é pra te desmotivar, e sim para dar uma perspectiva do real tamanho do desafio que vc tem pela frente.

Isso não é destrutivo, na minha concepção. Mostrar a realidade é algo que pode chocar e desmotivar, mas minha intenção foi mostrar algo que vc não estava percebendo, para que a partir daí vc possa reavaliar suas ações.

Dito isso, vc queria o que? Se alguém me dá uma ideia ruim, eu prefiro explicar porque eu acho ruim.

Vc queria que a gente só dissesse “Uau, que ideia incrível!” e não apontasse nenhum dos problemas que ela tem? Na minha opinião, apoiar uma ideia claramente ruim é muito mais destrutivo do que criticá-la, pois vai te fazer perder tempo em algo que não vai dar o resultado que vc espera.

JorgeLuizGSousa 23 de fev. de 2026

A impressão minha é que estão me chamando de burro!
Pra quê textão?
Vocês pelo menos olhou o código?

JorgeLuizGSousa 23 de fev. de 2026

Se me conhecesse direito, não diriam essas coisas!

hugokotsubo 23 de fev. de 2026

Sim, eu vi o código e mantenho minha opinião. Ninguém te chamou de burro, estamos apenas apontando detalhes que vc não percebeu. E são tantas coisas que não dá pra fazer isso com uma ou duas frases, então desculpe, mas o texto vai ser longo sim. Cabe a vc aproveitar o que está escrito ou ignorar.

Só pra dar um exemplo de conversão que não é óbvia. Python tem generators, um conceito para o qual não há equivalente em Java. Até é possível simular algo parecido, mas olha o trabalho que dá. Seu projeto vai fazer isso automaticamente? Para todos os corner cases possíveis?

E isso que estamos falando de um recurso específico de uma linguagem. Agora imagine todos os recursos de todas as linguagens que vc quer incluir no seu projeto.

E mesmo que duas linguagens possuam recursos parecidos, nem sempre é 100% igual. Tradução de código entre linguagens é complicado, não dá pra fazer uma correspondência linha a linha, comando a comando, exceto em programas muito simples (e olha lá).

Mesmo coisas mais simples podem ser difíceis de traduzir. Por exemplo, em Java os tipos numéricos possuem tamanhos fixos (inteiro sempre tem 32 bits, long sempre tem 64, etc). Em Python o limite para um número inteiro é a memória, em C depende da arquitetura, etc. Qualquer conversor teria que lidar com esses limites e fazer o tratamento adequado para que o código tenha sempre o mesmo resultado. Para números pequenos é simples, mas para todos os casos é complicado, provavelmente vai ter que fazer algumas concessões (“para valores acima de X não vai funcionar”, etc) e documentar bem esses casos para que o usuário não tenha surpresas.

Sem contar que há diferenças nos operadores. Em Java e C, a divisão de dois números inteiros resulta em um inteiro, então 7 / 2 dá 3. Em Python e JavaScript dá 3.5, além disso em Python há a mudança de tipo (int dividido por int resultou em float), mas em JS não porque só existe o tipo Number (não há separação entre inteiros e floats).

Mais ainda, Python tem o operador // (divisão inteira), então 7 // 2 resulta em 3. Indo além, há a função divmod que retorna a divisão e o resto de uma vez:

resultado_divisao, resto = divmod(7, 2)

E veja pelo código acima que dá para atribuir duas variáveis de uma vez: divmod retorna uma tupla com dois elementos (o resultado da divisão e o resto), mas dá para fazer o unpacking e já colocar cada valor em uma variável.

Como fazer isso em Java, que não possui este recurso? Não dá, vc teria que atribuir manualmente cada elemento em uma variável.

Enfim, esses são apenas alguns exemplos de recursos que uma linguagem possui e outra não, e mostra que a conversão nem sempre é óbvia e simples.

E isso não é uma “crítica destrutiva”, muito pelo contrário. É apenas para te dar uma noção melhor do desafio que vc tem pela frente. Vc está olhando para uma minúscula parte do problema. Existe um mundo de coisas que vc nem sequer imaginou, mas caso continue no projeto, mais cedo ou mais tarde acabaria encontrando. Então é melhor já ir pensando nisso…

vito 23 de fev. de 2026 1 like

Eita… Parabéns pela paciência nas respostas, vocês foram muito cordiais

hugokotsubo 23 de fev. de 2026 1 like

Pois é, tentamos ajudar, em vão.

Pelo jeito o cara não quer ser ajudado, preferiu ignorar tudo que escrevemos e ficou insistindo nessa coisa de “estão me chamando de burro”, sendo que ninguém fez isso.

Enfim, não tem mais o que fazer…

iireinar1 23 de fev. de 2026 2 likes

Na boa, acho que esse vai ser meu segundo comentário após vários anos acompanhando esse fórum, mas alguém deveria fechar esse tópico. Já ficou mais do que claro que esse cara ou é um troll ou tem questões pessoais que vão muito além do que devem ser discutidas aqui.

Criado 20 de fevereiro de 2026

Ultima resposta 23 de fev. de 2026

Respostas 35

Participantes 7

35 Respostas

Topicos relacionados