GUJ Discussões   :   últimos tópicos   |   categorias   |   GUJ Respostas

GERADOR DE SENHA Alfanumerico


#1

este é um exemplo bem simples de gerador de senhas alfanumeros...
se alguem quizer melhorar fique a vontade, mas posta aqui pra gnt conferir...

package senha;

/**
*
* @author Walfrides Marçal
Academico do 3º ano de Sistemas de Informação - FIMES - Mineiros - GO
*/
public class Main {

public Main() {
}


public static void main(String[] args) {


    String[] carct ={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};

    String senha="";


    for (int x=0; x<10; x++){
        int j = (int) (Math.random()*carct.length);
        senha += carct[j];

}

    System.out.println("A SENHA GERADA É: "+senha);

}

}

falowssssss

:smiley:


#2

Muito obrigado amigo.. era o que estavo procurando..

polpou bastante tempo de nao precisar digitar o Array :smile:

Abraços


#3

Com base no código dele fiz algumas alterações..

public static String getRandomPass(int len){
char[] chart ={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
char[] senha= new char[len];
int chartLenght = chart.lenght;
Random rdm = new Random();
for (int x=0; x<len; x++)
senha[i] = chart[rdm.nextInt(chartLenght)];
return new String(senha);
}

#4

Fiz um codigo parecido tambem.. é como se fosse um que nem o seu, mas em vez de enviar o numero de caracteres por parametro, achei melhor colocar tudo no metodo main mesmo :smile:

import java.util.Scanner;
import java.util.Random;
class Gerador_de_Senhas {
   public static void main(String args[]){
      Scanner scan = new Scanner(System.in);
      Random ran = new Random();
      String[] letras ={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
	  String b = "";
	  System.out.print("Digite o numero de caracteres para sua senha: ");
	  int num = scan.nextInt();
	  for ( int i = 0; i < num; i++){
	    int a = ran.nextInt(letras.length);
		b += letras[a];
	  }
	  System.out.print("Senha gerada: " + b);
   }
}

Abraços


#5

Que tal:

import java.util.Random;
public class PasswordGenerator {
	private static final char[] ALL_CHARS = new char[62];
	private static final Random RANDOM = new Random();
	static {
		for (int i = 48, j = 0; i < 123; i++) {
			if (Character.isLetterOrDigit(i)) {
				ALL_CHARS[j] = (char) i;
				j++;
			}
		}
	}
	public static String getRandomPassword(final int length) {
		final char[] result = new char[length];
		for (int i = 0; i < length; i++) {
			result[i] = ALL_CHARS[RANDOM.nextInt(ALL_CHARS.length)];
		}
		return new String(result);
	}
	public static String getRandomPassword() {
		return getRandomPassword(8);
	}
	private PasswordGenerator() {
	}
}

Funciona bem com até um milhão de caracteres. A partir disso fica lento e com mais de 10 milhões trava. Mas é bem divertido. :smiley:


#6

 static {  
         for (int i = 48, j = 0; i < 123; i++) {  
             if (Character.isLetterOrDigit(i)) {  
                 ALL_CHARS[j] = (char) i;  
                 j++;  
             }  
         }  
     }

A unica parte interessante que tava faltando no que postei..

Eu tava pensando em como fazer isso mas sem compilador fica difiçil e nem fui olhar na API XD


#7

Se o número de letras e dígitos for limitado a no máximo 12 e você não fizer diferença entre minúsculas e maiúsculas, pode usar o fato que a base 36 usa os dígitos de 0 a 9 e as letras de a até z, e gerar um número aleatório (usando a classe java.util.Random, método nextLong) que vá de 0 a 4738381338321616895. Converta o número para base-36 usando Long.toString (número, 36).


#8

minha solução foi a seguinte

public class RandomAlphaNumeric {
    private static final Random random = new Random();
    //não faz sentido instanciar essa classe
    private RandomAlphaNumeric() {}
    //[0 - 9] =  0-9
    //[A - Z] = 10-35
    //[a - z] = 36-61
    private static char toChar(int index) {
        if (index < 10)
            return (char)(index + 48); //os chars 48 a 57 representam [0 - 9]
        else if (index < 36)
            return (char)(index + 55); //os chars 65 a 90 representam [A - Z]
        else
            return (char)(index + 61); //os chars 97 a 122 representam [a - z]
    }
    //char randomico entre [0 - 9], [A - Z] e [a - z]
    public static char randomChar() {
        return toChar(random.nextInt(62));
    }
    //String randomica de tamanho length, contendo apenas caracters alfanumericos
    public static String randomString(int length) {
        return new String(randomCharSequence(length));
    }
    //sequencia de caracters randomicos de tamanho length, contendo apenas alfanumericos
    public static char[] randomCharSequence(int length) {
        if (length < 0)
            throw new IllegalArgumentException("O tamanho da string não pode ser negativo");
        if (length == 0)
            return new char[0];
        char[] charSequence = new char[length];
        for (int i = 0; i<length; i++)
            charSequence[i] = randomChar();
        return charSequence;
    }
    //sequencia de caracters randomicos de tamanho entre minLength e maxLength, contendo apenas carcters alfanumericos
    public static String randomString(int minLength, int maxLength) {
        if (minLength ><0 || maxLength < 0)
            throw new IllegalArgumentException("O tamanho da string não pode ser negativo");
        if (minLength > maxLength)
            throw new IllegalArgumentException("O tamanho maximo da String não pode ser menor que o minimo");
        if (minLength == maxLength)
            return randomString(maxLength);
        int size = minLength + random.nextInt(maxLength-minLength+1);
        return randomString(size);
    }
}

um exemplo de uso

public class NewMain {
    public static void main(String[] args) {
        System.out.println(RandomAlphaNumeric.randomString(100));
    }
}

resposta do console foi

"jYKXavayOno4K20p7VHWKVe92H7BvBMOIRy4N8RhI9ZJVDdLMzG4ah9RoUHTH6fkdmoYO6YBwDEffoKldiw3mvncVhP19TjPTdw3"


#9

adcionei o método

public static String randomString(int minLength, int maxLength)

e fiz um pequeno teste

    public static void main(String ... args) {
        for (int i = 0; i < 10; i++)
            System.out.println("\"" + randomString(0,8) + "\"");
    }

o resultado obtido no console foi

"k"
"gj35"
""
"FU2mqXdH"
"t7P9"
"UL"
"r7AUEH"
"1t"
"mJo4BzX"
"V6lclw"

#10

Galera, olhem meu codigo fazendo favor:

import java.util.Scanner;
import java.util.Random;
public class Gerador {
   public static void main(String args[]){
      Scanner scan = new Scanner(System.in);
	  Random ran = new Random();
	  System.out.print("1 - Escrever os caracteres para gerar a senha\n2 - Escolher o numero de caracteres para gerar a senha\n3 - Gerar senha de 8 digitos\n\n");
	  System.out.print("Escolha sua opcao: ");
	  int opcao = scan.nextInt();
	  switch ( opcao ) {
	  case 1: {
	     String senha = "";
		 int i;
	     System.out.print("Escreva os caracteres que deseja gerar a senha: ");
		 String car = scan.next();
		 String[] carac = car.split("");
		 for ( i = 0; i < carac.length; i++) {
		    int a = ran.nextInt(carac.length);
			senha += carac[a];
		 }
		 System.out.println("A senha gerada e: " + senha);
		 break;
	  }
	  case 2: {
	     String[] letras_mai ={"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
	     String[] letras_min ={"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
	     String[] numeros = {"0","1","2","3","4","5","6","7","8","9"};
	     System.out.print("Digite o numero de letras maisculas: ");
	     int str1 = scan.nextInt();
	     System.out.print("Digite o numero de letras minusculas: ");
	     int str2 = scan.nextInt();
	     System.out.print("Digite o numero de numeros: ");
	     int str3 = scan.nextInt();
	     int i;
	     String ger1 = "",ger2 = "",ger3 = "",str = "", tot = "";
	     for (i = 0; i < str1; i++ ){
	        int a = ran.nextInt(letras_mai.length);
		    ger1 += letras_mai[a];
	     }
		 for (i = 0; i < str2; i++) {
		    int a = ran.nextInt(letras_min.length);
			ger2 += letras_min[a];
		 }
		 for (i = 0; i < str3;i++){
		    int a = ran.nextInt(numeros.length);
			ger3 += numeros[a];
		 }
		 str = ger1 + ger2 + ger3;
		 String[] total = str.split("");
		 for (i = 0; i < total.length; i++){
		    int a = ran.nextInt(total.length);
			tot += total[a];
		 }
		 System.out.println("A senha gerada e: " + tot);
         break;
	  }
	  case 3: {
	     String[] letras ={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
		 String b = "";
	     for (int i = 0; i < 8; i++){
		    int a = ran.nextInt(letras.length);
			b += letras[a];
		 }
		 System.out.print("A senha gerada e: " + b);
		 break;
	  }
      }
   }
}

Esta dando erro no case 1 e 2. Quem conseguir resolver, se for possivel, poderia explicar aonde estava o erro e porque mudou para tal coisa..

Obrigado pela ajuda.

Abraços


#11

Em ambos os casos você usa o Random para pegar uma posição num array. Mas isso não garante que todos os valores serão escolhidos, nem que os valores não se repetirão. Por causa disso obtem-se valores repetidos e nem todos funcionam bem. A lógica deve ser revista levando isso em consideração.


#12

Para quem estiver interessado no meu blog tem um exemplo de gerador de senhas com codigo fonte, usa um interface swing.
Está na parte de downloads.

[]'s


#13

Porque nao garantem que todos valores serao escolhidos?


#14

Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?


#15

Entendi.. mas o que isso tem haver com os erros que estao ocorrendo com o codigo?

Obrigado pela ajuda galera!

Abraços


#16

[quote=marcobiscaro2112]Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?[/quote]

e o que isso tem a ver marco ?? a chance é de 1/10 de um número ser escolhido... isso não quer dizer que é um evento sem reposição, onde quando 1 é escolhido, a chance passa a ser de 1/9 para os outros...

acho que essa sua especulação, que em um for de 10 de rnd.nextInt(10) deve aparecer todos os números é algo totalmente equivocado....

lembre-se.... a chance é de 1/10 para cada vez que vc roda o evento... quando vc passa pela segunda vez no for, é como se o 1° evento não tivesse ocorrido, a chace continua sendo de 1/10 para qualquer número, sendo assim em 10 vezes a chance de um número se repetir é extremamente alta.... e a chance de os números nunca se repetirem, e de aparecer os 10 números na sequencia é extremamente baixa


#17

A probabilidade de os números não se repetirem no programa proposto (10 iterações de nextInt (10)), supondo que o gerador de números aleatórios seja perfeito, é de:

10! / 10^10 = 0,00036288 , ou seja, 0,036%.


#18

a conta do thingol esta correta, apenas para não deixar dúvidas

10! / (10 ^ 10)

pois
- para o 1° evento a chance de não c repetir é de 10 em 10 ou seja 10/10 visto que pode ocorrer qualquer número, pois nenhum número foi tirado anteriormente
- para o 2° evento a chance de não c repetir é de 9 em 10 ou seja 9/10, visto que podem ocorrer todos os números menos o anterior
- para o 3° evento a chance de não c repetir é de 8 em 10 ou seja 8/10, visto que podem ocorrer todos os números menos os 2 números anteriores
- ...
- para o 10° evento a chance de não c repetir é de 1 em 10 ou seja 1/10, visto que não pode ocorrer os 9 números anteriores

como queremos que o 1° evento não se repita, e o 2° e o 3° .... e o 10° devemos multiplicar as probabilidades de cada evendo, tendo então
10/10 * 9/10 * 8/10 * 7/10 ... 1/10 = 10! / (10 ^ 10)

o que da 00,0363% de chance dos números não se repetirem
e 99,9647% de chance de haver repetição de números


#19

Você está obtendo algum erro de compilação ou somente inconsistência de dados?

Se for só problema com os dados, é por causa dos números repetidos. Por exemplo, você manda gerar uma senha com 3 letras maiúsculas e 5 números. Se a lógica anterior for usada, valores irão repetir e seu resultado dificilmente terá 3 letras maiúsculas e 5 números de fato.


#20

[quote=Lavieri][quote=marcobiscaro2112]Porque o Random não gera um número randômico, e sim um número pseudo-randômico, que teoricamente (e apenas teoricamente) tem chance igual de ser escolhido dentre todas as possibilidades. Mas na prática isso é diferente. Experimente fazer o seguinte: crie uma classe com o método main e coloque o seguinte código:

Random rnd = new Random();
for (int i = 0; i < 10; i++) {
    System.out.println(rnd.nextInt(10));
}

A pergunta é: todos os números são sorteados sem se repetir?[/quote]

e o que isso tem a ver marco ?? a chance é de 1/10 de um número ser escolhido... isso não quer dizer que é um evento sem reposição, onde quando 1 é escolhido, a chance passa a ser de 1/9 para os outros...

acho que essa sua especulação, que em um for de 10 de rnd.nextInt(10) deve aparecer todos os números é algo totalmente equivocado....

lembre-se.... a chance é de 1/10 para cada vez que vc roda o evento... quando vc passa pela segunda vez no for, é como se o 1° evento não tivesse ocorrido, a chace continua sendo de 1/10 para qualquer número, sendo assim em 10 vezes a chance de um número se repetir é extremamente alta.... e a chance de os números nunca se repetirem, e de aparecer os 10 números na sequencia é extremamente baixa[/quote]

Mas foi exatamente isso que eu disse!!! Ele estava com problemas na senha gerada e eu disse que não necessariamente obteremos todos os números, e que há a possibilidade de obter-se números repetidos. Não disse que "em um for de 10 de rnd.nextInt(10) deve aparecer todos os números". Disse exatamente o contrário: que isso é incerto.