Um desafio lançado por uma amiga minha

Muito obrigado por responder.
Não entendi. :oops:
A minha amiga disse que o objetivo era encontrar todos os números de 4 algarismos que obedecem ao padrão exemplificado anteriormente.

E não rodou aqui. Marquei no código onde aparece com erro aqui no Eclipse.

public static void main(String[] args) throws SQLException { //Deu erro nessa linha aqui -This method has a constructor name; -SQLException cannot be resolved to a type;

raf4ever:

public class Main {

	public static void main(String[] args) throws SQLException { //Deu erro nessa linha aqui
		try{
			boolean result = testa(2025);
			System.out.println(result);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	public static boolean testa(int numero){
		String string = new Integer(numero).toString();
		int primeiro = new Integer(string.substring(0,2));
		int segundo = new Integer(string.substring(2,4));
		int resultado = primeiro+segundo;
		return (resultado*resultado) == numero;	
	}

}

to ficando eh doido,n sei de onde botei essa SQLException

pode remover esse trecho.

Programa divertido esse!... :D
Depois diz me se funcionou!... :lol:

public class NumerosDivertidos {  
      
        public static void main(String[] args) {
              for(int numero=1000; numero<10000; numero++){
                   int doisPrimeiros = numero/100;
                   int doisUltimos = numero - doisPrimeiros*100;
                   
                   int somaDosDois = doisPrimeiros + doisUltimos;
                   if(numero==somaDosDois*somaDosDois) {
                         Systeam.out.println("Numero: " + numero + "\nDois Primeiros: " + doisPrimeiros + "\nDois Ultimos: " + doisUltimos + "\nSoma: "+somaDosDois);
                   }

              }
        } 
    }

pode ser assim tbm:

public static void main(String[] args) {
		for (int num = 1000; num < 10000; num++) {
			int part1 = num / 100;
			int part2 = num % 100;
			int novoNum = part1 + part2;
			if (num == Math.pow(novoNum, 2)) {
				System.out.println(num);
			}
		}
	}

public static void main(String[] args) {
		for (int numero = 1000; numero< 10000; numero++) {
			int somaNumero = numero/100 + numero%100;
			if (numero/somaNumero == somaNumero) {
				System.out.println(numero);
			}
		}
	}

Sweet!.. Programação é muito divertido!..

wellington.nogueira:

wellington.nogueira:

int tempPart1 = 1000; for(int part1 = 10; part1 < 100; part1++) { for(int part2 = 0; part2 < 100; part2++, tempPart1++) { int sum = part1 + part2; if(tempPart1 == sum * sum) { System.out.println(tempPart1); } } }

Esqueci de dizer, minha intenção aqui é não haver, a cada iteração, um cálculo de divisão e um cálculo de módulo.

Cara, aninhar loops não é legal… Potencia a complexidade do seu código, e acredite isso não é bom.

Não acho uma boa idéia… Pois não é uma solução ótima.

[]'s

wellington.nogueira:

JM4X:

wellington.nogueira:

wellington.nogueira:

int tempPart1 = 1000; for(int part1 = 10; part1 < 100; part1++) { for(int part2 = 0; part2 < 100; part2++, tempPart1++) { int sum = part1 + part2; if(tempPart1 == sum * sum) { System.out.println(tempPart1); } } }

Esqueci de dizer, minha intenção aqui é não haver, a cada iteração, um cálculo de divisão e um cálculo de módulo.

Cara, aninhar loops não é legal… Potencia a complexidade do seu código, e acredite isso não é bom.

Não acho uma boa idéia… Pois não é uma solução ótima.

[]'s

Quanto a aumentar a complexidade, até concordo contigo. Realmente aumentou (em casos assim o código deve ser muito bem documentado), porém, nem sempre isso significa que a solução não seja ótima.
Como disse, minha intenção, neste caso, foi eliminar as operações de multiplicação e divisão.
Aliás, você disse que minha solução não é ótima. Poderia nos dizer o porquê?

PS: Eu acho legal aninhar loops :P

Amigo, não foi intenção nenhuma ofender vc.
Quando eu falei sobre complexidade, não estava me referindo a leitura do código e sim à execução dele.

Logo se um algoritmo tem uma COMPLEXIDADE que não seja a mínima possível, ele não é ÓTIMO.

Se você acha legal aninhar loops, tome cuidado…

[]'s

É interessante não considerei todas as possibilidade, isso é muito perigoso!.. Thanks!..
Programação é divertido :lol:

Ok, está certo. Para um código com entradas definidas e limitadas roda legals…

As minhas justificativas só servem para quando se tem entradas não limitadas,
conforme a entrada fosse aumentando, se notaria a diferença inversa.

[]'s

Engraçado, pra mim, a solução do JM4X está com resultado diferente do HelberChoo.
Mas acho que o problema é que não está sendo considerado o resto na solução do HelberChoo:

De qualquer forma, fiz uma outra solução:

int tempPart1 = 1000; for(int part1 = 10; part1 < 100; part1++) { for(int part2 = 0; part2 < 100; part2++, tempPart1++) { int sum = part1 + part2; if(tempPart1 == sum * sum) { System.out.println(tempPart1); } } }

wellington.nogueira:

int tempPart1 = 1000; for(int part1 = 10; part1 < 100; part1++) { for(int part2 = 0; part2 < 100; part2++, tempPart1++) { int sum = part1 + part2; if(tempPart1 == sum * sum) { System.out.println(tempPart1); } } }

JM4X:

wellington.nogueira:

wellington.nogueira:

int tempPart1 = 1000; for(int part1 = 10; part1 < 100; part1++) { for(int part2 = 0; part2 < 100; part2++, tempPart1++) { int sum = part1 + part2; if(tempPart1 == sum * sum) { System.out.println(tempPart1); } } }

Esqueci de dizer, minha intenção aqui é não haver, a cada iteração, um cálculo de divisão e um cálculo de módulo.

Cara, aninhar loops não é legal… Potencia a complexidade do seu código, e acredite isso não é bom.

Não acho uma boa idéia… Pois não é uma solução ótima.

[]'s

PS: Eu acho legal aninhar loops

JM4X:

Amigo, não foi intenção nenhuma ofender vc.
Quando eu falei sobre complexidade, não estava me referindo a leitura do código e sim à execução dele.

Logo se um algoritmo tem uma COMPLEXIDADE que não seja a mínima possível, ele não é ÓTIMO.

Se você acha legal aninhar loops, tome cuidado…

[]'s

Só não concordo plenamente com sua opinião:

Já vi alguns códigos que implicavam em performance que eram um tanto quanto complexos de compreender mas eram bem perfomáticos (incluindo loops aninhados). Mas não quer dizer que seja regra. Em linhas gerais, o que você disse é verdade. Mas ela não deve ser encarada como absoluta

E quanto a eu gostar de loops aninhados, só estava brincando hehe.

Para sabermos se o código é ou não performático, só um profiler para saber (e vou fazer o teste para confirmar, só por curiosidade).

package test;

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

public class Test {

    public static void main(String[] args) {
        //Este loop é só para garantir que tudo estará em memória. Seus resultados devem ser desconsiderados.
        for(int i = 0; i < 4; ++i) {
            Testme test = new Testme();
            test.firstTest();
            test.secondTest();
            test.clear();
            
        }
        //Chamada a ser analisada.
        realTest();
    }

    private static void realTest() {
        Testme test = new Testme();
        test.firstTest();
        test.secondTest();
        
        System.out.println(test);
        test.clear();
    }
}

class Testme {
    //Criei estas listas para "eliminar" o gap de mandar o texto para a console
    List<Integer> firstList = new ArrayList<Integer>();
    List<Integer> secondList = new ArrayList<Integer>();
    
    public void firstTest() {
        for (int num = 1000; num < 10000; num++) {  
            int part1 = num / 100;  
            int part2 = num % 100;  
            int novoNum = part1 + part2;  
            if (num == Math.pow(novoNum, 2)) {  
                firstList.add(num);
            }  
        }  
    }
    
    public void secondTest() {
        int tempPart1 = 1000;  
        for(int part1 = 10; part1 < 100; part1++) {  
            for(int part2 = 0; part2 < 100; part2++, tempPart1++) {  
                int sum = part1 + part2;  
                if(tempPart1 == sum * sum) {  
                    secondList.add(tempPart1);  
                }  
            }  
        } 
    }

    @Override
    public String toString() {
        //Imprime ambos os resultados
        return String.format("%s\n%s", firstList, secondList);
    }
    
    /** Limpa ambas as listas */
    public void clear() {
        firstList.clear();
        secondList.clear();
    }
}

Anexei o resultado do profiler. Se fiz certo, o resultado encontra-se aí.

HelberChoo:

É interessante não considerei todas as possibilidade, isso é muito perigoso!.. Thanks!..
Programação é divertido :lol: