12

#PlatziCodingChallenge - Generador de contraseñas

11. Generador de contraseñas

Un ejercicio que siempre resulta útil para aplicar aleatoriedad es la generación de contraseñas. Básicamente debes crear un string de caracteres al azar tomando en cuenta las siguientes condiciones que el usuario debe poder elegir:

  • Longitud de la contraseña.
  • Si incluirá minúsculas, mayúsculas, números y caracteres especiales (incluyendo espacios).

Reglas del reto

Escribe tu comentario
+ 2
Ordenar por:
4
10710Puntos
import string
import random

defgenerator(options, length):
    password = ""
    long_chars = "".join(options.values())
    for _ in range(length):
        password += random.choice(long_chars)
        
    return password

defmain():
    print("Password Generator".center(50))
    
    length = int(input("Password length: "))

    options = {
        "numbers": string.digits,
        "lower case": string.ascii_lowercase,
        "upper case": string.ascii_uppercase,
        "special characters": string.punctuation + " "
    }

    print("Complexity")
    print("Enter 0 to exclude, any other value will be accepted")
    for index, option in enumerate(options.keys()):
        selected = input(f"{index + 1}. {option.capitalize()}: ")
        if selected == '0':
            options[option] = ""ifnot any(options.values()):
        print("Password can not be generated.")
    else:
        password = generator(options, length)
        print(f"Your secure password is {password}")

if __name__ == "__main__":
    main()
1
10710Puntos
7 meses

Podria haber agregado

ifnotany(options.values()) orlength <= 0

para indicar que no se puede generar la contraseña en caso de que la longitud sea menor a 1

1
2446Puntos
7 meses

Hola @estebansolorzano,
Trate de ejecutarlo y no me funcionó, tu código esta en python?
o en que lenguaje?
Saludos!

4
10710Puntos
7 meses

Hola, si esta en python, tal vez por lo que el editor pega partes del codigo? aqui puedes verlo por si lo quieres revisar

4
2446Puntos

Hola les dejo mi código minimalista por demás, espero sus comentarios, tengo mucho tiempo sin programar y aprender Python me genera mucha ilusión, son muchas lunas desde que codifique mis primeras líneas en Basic, saludos!

# Generador de Contraseña

import random# inclusión de librería

longitud_password = 0# declaración de variable numérica
password = ''# declaración cadena alfanumérica

longitud_password = int(input('Ingrese la longitud de la Clave requerida: ')) 

for num in range(longitud_password):
    password = password + chr(int(random.randint(32, 126))) 

print('Clave Generada: ', password)
2
26494Puntos
7 meses

Me parece muy útil la forma en que seleccionas caracteres diferentes con la conversión chr(). El detalle que veo en el código que hiciste es que no se le permite al usuario escoger los tipos de caracteres como se menciona en las condiciones del ejercicio.

En dado caso esa línea de código servirá muy bien para la condición donde se incluyan todo tipo de caracteres. 😃

1
2446Puntos
7 meses

Gracias Miguel!
Lo voy a agregar,
Saludos!

2
7689Puntos

Y seguimos c:

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Generador de Contraseñas</title></head><style>
  * {
    margin: 0;
  }

  .contenedor {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    height: 100vh;
  }

  .section {
    padding: 2rem;
  }

  .inputs {
    display: inherit;
    align-items: center;
  }

  .btn {
    border: 2px solid black;
    border-radius: 6px;
    cursor: pointer;
  }

  #contra {
    padding: 020px;
    width: 95%;
  }
</style><body><divclass="contenedor"><divclass="inputs"><sectionclass="section">
        Longitud de la contraseña: <inputid="longitud"/></section><buttononclick="crearContra()"class="btn">Crear...</button></div><textareaid="contra"disabled></textarea></div><script>functioncrearContra(){
      const longitud = document.getElementById('longitud').value
      let contraseña = ''while (contraseña.length < longitud){
        let variable = Math.floor(Math.random()*127)
        if (variable >= 32 && variable <= 126) {
          let char = String.fromCharCode(variable)
          contraseña = contraseña.concat(char)
        }
        console.log(variable, contraseña)
      }
      console.log(contraseña.length)
      console.log(contraseña)
      document.getElementById('contra').value = contraseña
    }
  </script></body></html>
1
7689Puntos
7 meses

Pues me di cuenta que entendí mal la directriz, aquí esta el resultado corregido:

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Generador de Contraseñas</title></head><style>
  * {
    margin: 0;
  }

  .contenedor {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    height: 100vh;
  }

  .section {
    padding: 2rem;
  }

  .inputs {
    display: inherit;
    align-items: center;
    flex-direction: column;
  }

  .btn {
    border: 2px solid black;
    border-radius: 6px;
    cursor: pointer;
  }

  #contra {
    margin-top: 16px;
    padding: 020px;
    width: 50%;
    text-align: center;
  }
</style><body><divclass="contenedor"><h1>Generador de Contraseñas</h1><divclass="inputs"><sectionclass="section">
        Minúsculas? <selectname="min"id="min"><optionvalue="true">Si</option><optionvalue="false">No</option></select>
        Mayúsculas? <selectname="mayus"id="mayus"><optionvalue="true">Si</option><optionvalue="false">No</option></select>
        Números? <selectname="num"id="num"><optionvalue="true">Si</option><optionvalue="false">No</option></select>
        Caracteres Especiales? <selectname="esp"id="esp"><optionvalue="true">Si</option><optionvalue="false">No</option></select></section><sectionclass="section">
        Longitud de la contraseña: <inputid="longitud"/></section><buttononclick="crearContra()"class="btn">Crear...</button></div><textareaid="contra"disabled></textarea></div><script>functioncrearContra(){
      const longitud = document.getElementById('longitud').value
      const min = document.getElementById('min').value
      const mayus = document.getElementById('mayus').value
      const num = document.getElementById('num').value
      const esp = document.getElementById('esp').value

      if (min === 'false' && mayus === 'false' && num === 'false' && esp === 'false'){
        return alert('Selecciona al menos una opción en "si"')
      }

      const datos = {
        num: [48,49,50,51,52,53,54,55,56,57],
        min: [97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122],
        mayus: [65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90],
        esp: [32,33,34,35,36,37,39,40,41,42,43,44,45,46,47,58,59,60,61,62,63,64,91,92,93,94,95,96,123,124,125,126]
      }

      let rango = []

      const keys = Object.keys(datos)

      let contraseña = ''if (min === 'true'){
        rango.push(datos.min)
      }
      if (mayus === 'true'){
        rango.push(datos.mayus)
      }
      if (num === 'true'){
        rango.push(datos.num)
      }
      if (esp === 'true'){
        rango.push(datos.esp)
      }

      rango = rango.flat(1)

      while (contraseña.length < longitud){
        let variable = Math.floor(Math.random()*(rango.length))
        let char = String.fromCharCode(rango[variable])
        contraseña = contraseña.concat(char)
      }

      document.getElementById('contra').value = contraseña
    }
  </script></body></html>```
2
17784Puntos

import random

if name == ‘main’:
NUMEROS = list(‘0123456789’)
MAYUSCULAS = list(‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’)
MINUSCULAS = list(‘abcdefghijklmnopqrstuvwxyz’)
SIMBOLOS = list(’!"#$%&/()=?¡’)

longitud = int(input('De cuantos caracteres deseas que sea tu contraseña?: '))
mayusculas = input('Deseas usar mayusculas S/N: ')
minusculas = input('Deseas usar minusculas S/N: ')
numeros = input('Deseas usar numeros S/N: ')
especiales = input('Deseas usar caracteres especiales S/N: ')

password = ''
alfabeto = []

if (numeros.upper() == 'S'):
    alfabeto = alfabeto + NUMEROS
if (mayusculas.upper() == 'S'):
    alfabeto = alfabeto + MAYUSCULAS
if (minusculas.upper() == 'S'):
    alfabeto = alfabeto + MINUSCULAS
if (especiales.upper() == 'S'):
    alfabeto = alfabeto + SIMBOLOS

while len(password) < longitud:
    i = random.randint(0, len(alfabeto) - 1)
    letra = str(alfabeto[i])        
    password = password + letra

print(f'Tu contraseña es: {password}')
2
13595Puntos

Mi generador en java, por cierto este ejercicio estuvo muy entretenido.

public class PasswordGenerator {

    public String generatePassword(){
        boolean specialChar = false;
        StringBuilder password = new StringBuilder("");

        Scanner scan = new Scanner(System.in);System.out.println("Password length: ");int len = scan.nextInt();
        scan.nextLine();System.out.println("Do you want to use special characters? Y/N");
        String answer = scan.nextLine();if (answer.equalsIgnoreCase("y")){
            specialChar = true;
        }

        if (specialChar){
            for (int i = 0; i < len; i++) {int ranomNumber = (int) (Math.random() * ((237 - 33) + 1)) + 33;
                char character =  (char) ranomNumber;
                password.append(character);
             }
        }else {
            for (int i = 0; i < len; i++) {int ranomNumber = (int) (Math.random() * ((122 - 97 + 1)) )+ 97;
                char character =  (char) ranomNumber;
                password.append(character);
            }
        }

        return  password.toString();
    }
}


1
13944Puntos

Hecho en ruby

def generador(longitud, minusculas, mayusculas, numeros, caracteres)
  letras_min = Array('a'..'z')
  letras_may = Array('A'..'Z')
  numeros = Array(0..9)
  simbolos = ['~', '^', '?', '.', '/', '!', '#', '$', '%', '&']
  contrasenia = ''random = 0
  contador = 0while contador < longitud
    if numeros && (contador < longitud)
      random = rand(9)
      contrasenia<<(numeros[random]).to_s      
      contador += 1endifminusculas && (contador < longitud)random = rand(26)
      contrasenia<<(letras_min[random]).to_s      
      contador += 1endifmayusculas && (contador < longitud)random = rand(26)
      contrasenia<<(letras_may[random]).to_s
      contador += 1endifcaracteres && (contador < longitud)random = rand(10)
      contrasenia<<(simbolos[random]).to_s
      contador += 1endend
  puts "La contraseña generada es: #{contrasenia}"enddefmain
  puts "Ingrese la longitud: "
  longitud = gets.chomp.to_i
  generador(longitud, true, true, true, false)
endmain()
1
26494Puntos

Este me tomó más tiempo. Pude resolverlo con manipulación de listas y strings en Python.

from random import choice

MAYUS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z']
MINUS = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z']
NUMS = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
CHARS = ['*', '+', '-', '/', '@', '_', '?', '!', '[', '{', '(', ')', '}', ']', ',', ';', '.', '>', '<', '~', '°', '^', '&', '$', '#', '"']


defgenerador_contrasena(longitud, caracteres):

    password = ''for _ in range(longitud):
        caracter = choice(caracteres)
        password = password + caracter

    return password


defelegir_caracters():
    elegidos = []
    eleccion = input('\n¿Deseas incluir mayúsculas? Si/No: ').lower()
    if eleccion == 'si':
        elegidos.append('MAYUS')
    
    eleccion = input('\n¿Deseas incluir minúsculas? Si/No: ').lower()
    if eleccion == 'si':
        elegidos.append('MINUS')

    eleccion = input('\n¿Deseas incluir números? Si/No: ').lower()
    if eleccion == 'si':
        elegidos.append('NUMS')

    eleccion = input('\n¿Deseas incluir caracteres especiales? Si/No: ').lower()
    if eleccion == 'si':
        elegidos.append('CHARS')

    return elegidos


defgenerar_lista_caracteres(tipos_caracteres):

    lista_caracteres = []
    
    for tipo in tipos_caracteres:
        if tipo == 'MAYUS':
            lista_caracteres.extend(MAYUS)
        if tipo == 'MINUS':
            lista_caracteres.extend(MINUS)
        if tipo == 'NUMS':
            lista_caracteres.extend(NUMS)
        if tipo == 'CHARS':
            lista_caracteres.extend(CHARS)

    return lista_caracteres


if __name__ == "__main__":
    numero_caracteres = int(input('\nDefine la longitud de tu contraseña: '))
    caracteres_elegidos = elegir_caracters()
    lista_caracteres_elegidos = generar_lista_caracteres(caracteres_elegidos)
    contraseña_generada = generador_contrasena(numero_caracteres, lista_caracteres_elegidos)

    print(f'\n\tContraseña generada: {contraseña_generada}')
1
const password = prompt('Ingresa el numero de caracteresque quieres en tu contrasena:')

functiongenerateRandomString(password) {
    let characters = '[email protected]#$%^&*()_+=-{}|][":;<>?/.,~'let random_string = ''if(password > 0) {
        for(var i = 0; i < password; i++) {
        random_string += characters.charAt(Math.floor(Math.random() * characters.length))
        }
    }
    return random_string;
}
alert(generateRandomString(password))
1
9764Puntos

JS

console.clear();

const sC = ['!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', '\]', '^', '_', '`', '{', '|', '}', '~', 'Ñ', 'ñ'];
const uC = [...Array(26).keys()].map(i => String.fromCharCode(i + 65));
const lC = [...Array(26).keys()].map(i => String.fromCharCode(i + 97));
const nC = [...Array(10).keys()].map(i => parseInt(i));
let l = prompt('Password length?\r\Between 8 and 26 characters');
let c = prompt('Would use special characters\r\n 0 : No | 1 : Yes');
let u = prompt('Would use upper case?\r\n 0 : No | 1 : Yes');
let n = prompt('Would use numbers?\r\n 0 : No | 1 : Yes');

const EVERY_DAY_IM_SHUFFLING = (arr) => {
    for (let i = arr.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * i)
        const temp = arr[i]
        arr[i] = arr[j]
        arr[j] = temp
    }

    return arr;
}

const gp = (args) => {

    if (l >= 8) {
        let pA = [...lC];
        let sel = [];
        args.c == '' || args.c == '0' ? sel.push(0) : sel.push(1);
        args.u == '' || args.u == '0' ? sel.push(0) : sel.push(1);
        args.n == '' || args.n == '0' ? sel.push(0) : sel.push(1);

        for (let i = 0; i < sel.length; i++) {
            if (sel[i] == 1) {
                i == 0 ? pA = [...pA, ...sC] : i == 1 ? pA = [...pA, ...uC] : i == 2 ? pA = [...pA, ...nC] : '';
            }
        }

        let spA = EVERY_DAY_IM_SHUFFLING(pA);
        let divided = EVERY_DAY_IM_SHUFFLING(spA.slice(0, l));
        
        if(l > 26){
            return"Sorry I can't compute larger passwords."
        }else{
            return`Your password is:\r\ ${divided.join('')}`;
        }
        
    } else {
        return'The password length must be between 8 and 26 characters.';
    }
}

alert(gp({ l: l, c: c, u: u, n: n }));

1

En Python 😃

importrandomimport string

def generadorletras(cantidad,minusculas,mayusculas,numero,especiales):
    contraseña=[]
    decision=[]
    if minusculas=='si':
        decision.append(1)
    if mayusculas=='si':
        decision.append(2)
    if numeros=='si':
        decision.append(3)
    if especiales=='si':
        decision.append(4)
    for i in range(cantidad):
        eleccion=random.choice(decision)
        if eleccion==1:
            letra=random.choice(string.ascii_letters)
            letra=letra.lower()
            letra=str(letra)
            contraseña.append(letra)
        if eleccion==2:
            letra=random.choice(string.ascii_letters)
            letra=letra.upper()
            letra=str(letra)
            contraseña.append(letra)
        if eleccion==3:
            numero=random.randint(0,9)
            numero=str(numero)
            contraseña.append(numero)
        if eleccion==4:
            diccionario=[' ','|','°','¬','!','"','#','$','%','&','/','(',')','=','?','*','¿','¡','"','+','~','{','}','[',']',';',',',':','.','-','_','>','<']
            dicts=random.choice(diccionario)
            dicts=str(dicts)
            contraseña.append(dicts)
    contraseñas=''.join(contraseña)
    print(f'Tu contraseña es: "{contraseñas}" no la reveles')
cantidad=int(input('De cuantos caracteres quieres tu contraseña? '))
minusculas=str(input('Requieres minusculas en tu contraseña? '))
mayusculas=str(input('Requieres mayusculas en tu contraseña? '))
numeros=str(input('Requieres numeros en tu contraseña? '))
especiales=str(input('Requieres caracteres especiales en tu contraseña? '))
if __name__ == "__main__":
    generadorletras(cantidad,minusculas,mayusculas,numeros,especiales)```
1
2345Puntos

Generador de contraseñas en JS

const LNG = 8; //longitud deseada de la claveconst MIN = true; // incluye minusculas - ASCII 97 - 122const MAY = true; // incluye mayusculas - ASCII 65 - 90const NUM = true; // incluye numeros - ASCII 48 - 57const ESP = true; //incluye caracteres especiales - ASCII  32 - 47 incluye espacioconst DIST = LNG/(MIN + MAY + NUM + ESP) // asignamos un % participación para cada variable para obligar a mostrar caracteres según constantes activas. var c = "";
var clave = "";

//Generamos caracteres aleatorios segun constantes activasif(MIN){
    clave += caracteres(122,97)
}
if(MAY){
    clave += caracteres(90,65)
}
if(NUM){
    clave += caracteres(57,48)
}
if(ESP){
    clave += caracteres(47,32)
}

//imprimimos en consola la clave final mezcladaconsole.log(mixpass(clave));

//funcion para generar los carcteres aleatoriosfunctioncaracteres(max, min){
    let c = "";
    for( let i = 0; i < Math.ceil(DIST); i++){
        let rdm = Math.round(Math.random() * (max - min)) + min
        c += String.fromCharCode(rdm)
    }
    return c;
}

//funcion para mezclar la caracteres finales y ajustar cantidad de caracteres por redondeo.functionmixpass(txt){
    let t = [];
    let t2 = [];
    if(txt.length > LNG){
        t = Array.from(txt)
        t = t.sort(function() {return (Math.random()-0.5)});//mezclamos
        t2 = t.slice(0, ((txt.length) - (txt.length - LNG)))//ajustamos cantidad
    }else{
         t = Array.from(txt)
         t2 = t.sort(function() {return (Math.random()-0.5)});
    }
return t2.join('');
}

Resultado con todas las constantes activas:
LNG = 8 --> HWrf3!!2
LNG = 8 --> 7x%2j-CK
LNG = 10 --> 93zT)6EglD
Resultado con solo MAY y NUM activas:
LNG = 8 --> 1WP6VW35
LNG = 8 --> X7XD00C8
LNG = 10 --> QGS5K50M74
Resultado con solo MIN y ESP activas:
LNG = 8 --> jviy)! -
LNG = 8 --> (qb+f$e#
LNG = 10 --> gh/t(/ut*%

1
1047Puntos

En PHP 7.

✓ Longitud de la contraseña.
✓ Minúsculas, Mayúsculas, Números y Caracteres especiales

<?php
  /*
    Generador de contraseña

    Uso: [Request => POST] en este script;
    Input: (No requerido)(Por default: Password [largo: 8][Min & Num])
     $_POST['Longitud_Password']           [Requiere ser (num)(>=1)]
     $_POST['Min']  Minúsculas             [Requiere ser (num)(1 o 0)]
     $_POST['May']  Nayúsculas             [Requiere ser (num)(1 o 0)]
     $_POST['Num']  Números                [Requiere ser (num)(1 o 0)]
     $_POST['Car']  Caracteres especiales  [Requiere ser (num)(1 o 0)]

    Salida: Password [string][texto - plano] OR Error [string][texto - plano]
  */

  //Funciones
    function Check_option($var = "0") {
     if (empty($var)) {
       return "0";
     }
     if (ctype_digit($var)) {

      if (($var == "1") or ($var == "0")) {
        return $var;
      }else {
        echo "Umm.. el input de las opciones solo puede ser 1 o 0.";
        exit;
      }

     }else {
      echo "Hey, el input de las opciones deve estar compuesto solo de números.";
      exit;
     }
   }

  // Input del usuario:
    if (!empty($_POST['Longitud_Password'])) {        // Esta vacio ?
    if (ctype_digit($_POST['Longitud_Password'])) {   // Es un numero ?
    if ($_POST['Longitud_Password'] >= "1") {         // Es >= a 1

      $Longitud_Password = $_POST['Longitud_Password'];

    }else {
      echo "Umm la \"Longitud de la contraseña\" deve ser mayor o igual a uno.";
      exit;
    }
    }else {
      echo "Hey la \"Longitud de la contraseña\" deve ser un numero.";
      exit;
    }
    }else {
     // No se especifico largo de la password, por default: 8
     $Longitud_Password = "8";
    }

  // Opciones:
    $Minúsculas =  @Check_option($_POST['Min']);
    $Mayúsculas =  @Check_option($_POST['May']);
    $Números    =  @Check_option($_POST['Num']);
    $Caract_esp =  @Check_option($_POST['Car']);

  // Generando "Mapa de caracteres" segun las opciones que eligio el usuario
    $Mapa_caracteres = "";

    if ($Minúsculas) {$Mapa_caracteres = $Mapa_caracteres . "qwertyuiopasdfghjklzxcvbnm";}
    if ($Mayúsculas) {$Mapa_caracteres = $Mapa_caracteres . "QWERTYUIOPASDFGHJKLZXCVBNM";}
    if ($Números)    {$Mapa_caracteres = $Mapa_caracteres . "1234567890";}
    if ($Caract_esp) {$Mapa_caracteres = $Mapa_caracteres . "[email protected]#$%^&*()_+-=.,/'\][`]' ";}

    if (empty($Mapa_caracteres)) {
      //El usuario no uso ninguna opcion; por defecto:
      $Mapa_caracteres = "qwertyuiopasdfghjklzxcvbnm1234567890";
    }

  // Generando password
    $Password = '';

    $max = strlen($Mapa_caracteres)-1;
    for($i=0;$i < $Longitud_Password;$i++) $Password .= $Mapa_caracteres{mt_rand(0,$max)};
    echo $Password;
  // End

?>
1
6327Puntos

Generador de contraseñas en Java ☕️ ☕️

public class GeneradorDePassword {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        char[] allowedCharacters = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789".toCharArray();
        char[] specialCharacters = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ!\"#$%&'()*+,-./:;[email protected] {|}~_".toCharArray();
        SecureRandom random = new SecureRandom();
        StringBuffer password = new StringBuffer();System.out.println("Generador de contraeñas");System.out.println("Ingresa la longitud que deseas que tenga tu contraseña");intlength = scanner.nextInt();System.out.println("Ingresa 1 si quieres que la contraseña contenga " +
                "caracteres especiales o 2 para que no los contenga");int specials = scanner.nextInt();if (specials == 1) {
            for (int i = 0; i < length; i++) {
                password.append(specialCharacters[ random.nextInt(specialCharacters.length) ]);
            }
        } else {
            for (int i = 0; i < length; i++) {
                password.append(allowedCharacters[ random.nextInt(allowedCharacters.length) ]);
            }
        }
        System.out.println(password);
    }
}

Ejecución del programa con caracteres especiales

Ejecución del programa sin caracteres especiales

1
8259Puntos

Espero feedback 😄

let caracteres;
let password = "";
let opcion = Number(prompt("1. Todo tipo de caracteres| 2. Mayusculas y minusculas| 3. Solo minusculas| 4. solo mayusculas| 5. solo caracteres especiales")); 
let longitudPass = Number(prompt("¿Cual será la longitud de su contraseña?"));

function caracterAleatorio(caracteres) {
    for (let i = 1; i <= longitudPass; i++) {
        password = password + caracteres.charAt(Math.floor(Math.random()*((caracteres.length+1)-0)+0))    
    }
    return console.log(password);
}

switch (opcion) {
    case1:
        caracteres = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789abcdefghijklmnñopqrstuvwxyz*/()=&%$#!°|.-_:";
        caracterAleatorio(caracteres);break;case2:
        caracteres = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789abcdefghijklmnñopqrstuvwxyz";
        caracterAleatorio(caracteres);break;case3:
        caracteres = "abcdefghijklmnñopqrstuvwxyz0123456789";
        caracterAleatorio(caracteres);break;case4:
        caracteres = "abcdefghijklmnñopqrstuvwxyz0123456789";
        caracterAleatorio(caracteres);break;case5:
        caracteres = "*/()=&%$#!°|.-_:"
        caracterAleatorio(caracteres);break;default:
        alert("Opcion no valida")
        break;
1
1047Puntos
7 meses

En que lenguaje esta escrito ?, parece JS.

2
28589Puntos
7 meses

Es JS cuando te familiarices más con los lenguajes encontraras caracteristicias muy llamativas de cada uno, en este caso promt

1
4372Puntos

PYTHON

import random

defPassword_Generator(l,a):
    pg = ''if a == 1:
        x = 32
        y = 126else:
        x = 97
        y = 122while l > 0:
        pg = pg + chr(int(random.randint(x,y)))
        l -= 1
    
    print('-'*20)
    print(f'You Password is : {pg}')
         

if __name__ == '__main__':
    print("""
        GENERATE PASSWORD in Python
    -----------------------------------
    """)
    l = int(input('Password length : '))
    while l <= 0 :
        l = int(input('Password length (>0) : '))
    
    print('Do you want to include lower case, upper case, numbers and special characters (including spaces)?')
    print('1 : Yes')
    print('2 : No')

    a = int(input('You answer : '))
    if a notin (1,2):
        print(f'The answer {a} not is valid')
    else:
        Password_Generator(l,a)
password1.PNG
1
19943Puntos

Generador de contraseñas en JavaScript y en Python (en Python me pareció mas sencillo)
Use codigos ascii para generar los caracteres

// Generador de contraseñas en JavaScript// Caracteres UNICODE (32 - 126)const CODES_SYMBOLS1 = Array.from({length: 47 - 32 + 1}, (v, i) => i + 32) /* [32, 47] */const CODES_NUMBERS = Array.from({length: 57 - 48 + 1}, (v, i) => i + 48) /* [48, 57] */const CODES_SYMBOLS2 = Array.from({length: 64 - 58 + 1}, (v, i) => i + 58) /* [58, 64] */const CODES_UPPERLETTERS = Array.from({length: 90 - 65 + 1}, (v, i) => i + 65) /* [65, 90] */const CODES_SYMBOLS3 = Array.from({length: 96 - 91 + 1}, (v, i) => i + 91) /* [91, 96] */const CODES_LOWERLETTERS = Array.from({length: 122 - 97 + 1}, (v, i) => i + 97) /* [97, 122] */const CODES_SYMBOLS4 = Array.from({length: 126 - 123 + 1}, (v, i) => i + 123) /* [123, 126] */functiongeneratePassword(lenght, lower = true, upper = true, numbers = true, special = false) {
    /* WHICH CHARACTERS ARE ALLOWED */let charscodes = []
    if (special) {
        charscodes = charscodes.concat(CODES_SYMBOLS1)
        charscodes = charscodes.concat(CODES_SYMBOLS2)
        charscodes = charscodes.concat(CODES_SYMBOLS3)
        charscodes = charscodes.concat(CODES_SYMBOLS4)
    }
    if (numbers) charscodes = charscodes.concat(CODES_NUMBERS)
    if (lower) charscodes = charscodes.concat(CODES_LOWERLETTERS)
    if (upper) charscodes = charscodes.concat(CODES_UPPERLETTERS)
    /* ¿IS THERE ANY CHARACTER ALLOWED? */if (charscodes.length < 1) return'no se puede generar contraseña con estas condiciones'/* WRITING THE PASSWORD */let password = ''for (let i = 0; i < lenght; i++) {
        password += String.fromCharCode(charscodes[Math.floor(Math.random()*charscodes.length)])
    }
    return password
}

const largo = parseInt(prompt('¿Cuántos caracteres quiere en su contraseña?'))
const minusculas = prompt('¿Quiere que su contraseña permita minúsculas? (si/no)') == 'si'const mayusculas = prompt('¿Quiere que su contraseña permita mayúsculas? (si/no)') == 'si'const numeros = prompt('¿Quiere que su contraseña permita números? (si/no)') == 'si'const especiales = prompt('¿Quiere que su contraseña permita caracteres especiales? (si/no)') == 'si'
alert(`Su contraseña es: ${generatePassword(largo, minusculas, mayusculas, numeros, especiales)}`)
#Generador de contraseñas en Pythonfrom random import choice

#Caracteres UNICODE (32 - 126)
CODES_SYMBOLS1 = list(range(32, 47 + 1)) # [32, 47]
CODES_NUMBERS = list(range(48, 57 + 1)) # [48, 57]
CODES_SYMBOLS2 = list(range(58, 64 + 1)) # [58, 64]
CODES_UPPERLETTERS = list(range(65, 90 + 1)) # [65, 90]
CODES_SYMBOLS3 = list(range(91, 96 + 1)) # [91, 96]
CODES_LOWERLETTERS = list(range(97, 122 + 1)) # [97, 122]
CODES_SYMBOLS4 = list(range(123, 126 + 1)) # [123, 126]defgeneratePassword(lenght, lower = True, upper = True, numbers = True, special = False):# WHICH CHARACTERS ARE ALLOWED
    charscodes = []
    if (special):
        charscodes.extend(CODES_SYMBOLS1)
        charscodes.extend(CODES_SYMBOLS2)
        charscodes.extend(CODES_SYMBOLS3)
        charscodes.extend(CODES_SYMBOLS4)
    if (numbers): charscodes.extend(CODES_NUMBERS)
    if (lower): charscodes.extend(CODES_LOWERLETTERS)
    if (upper): charscodes.extend(CODES_UPPERLETTERS)
    # ¿IS THERE ANY CHARACTER ALLOWED?if (len(charscodes) < 1): return'no se puede generar contraseña con estas condiciones'# WRITING THE PASSWORD
    password = ''for i in range(0, lenght): password = password + chr(choice(charscodes))
    return password

largo = int(input('¿Cuántos caracteres quiere en su contraseña?: '))
minusculas = (input('¿Quiere que su contraseña permitas minúsculas? (si/no): ') == 'si')
mayusculas = (input('¿Quiere que su contraseña permita mayúsculas? (si/no): ') == 'si')
numeros = (input('¿Quiere que su contraseña permita números? (si/no): ') == 'si')
especiales = (input('¿Quiere que su contraseña permita caracteres especiales? (si/no): ') == 'si')
print('Su contraseña es: {}'.format(generatePassword(largo, minusculas, mayusculas, numeros, especiales)))
1
7078Puntos
import string
import random

defgenerarContrasenha(opc, can):
  passw = ""
  longitud_char = "".join(opc.values())
  for _ in range(can):
    passw += random.choice(longitud_char)
    return passw

    
cantidad = int( input("Cantidad de caracteres: ") )
opciones = {
  "numero": string.digits,
  "caracteres en minuscula": string.ascii_lowercase,
  "caracteres en mayuscula": string.ascii_uppercase,
  "caracteres especiales": string.punctuation + " "
}

for index, opcion in enumerate(opciones.keys()):
  selected = input(f"{index + 1}. {opcion.capitalize()}: ")
  if selected == '0':
    opciones[opcion] = ""ifnot any(opciones.values()) or cantidad <= 0:
  print("La contraseña no puede ser generada")
else:
  passw = generarContrasenha(opciones, cantidad)
  print(f"Su contraseña es {passw}")
1
5819Puntos

Generador de contraseñas en Python.

import random

defgenerar_contrasena():
    mayusculas = ['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']
    minusculas = ['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']
    simbolos = ['°', '!', '#', '$', '%', '&', '/', '(', ')', '?', '¿', '^', '.', '{', '}', '¡']
    numeros = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']


    caracteres = mayusculas + minusculas + simbolos + numeros

    contrasena = []

    for i in range(int(input('Cuantos caracteres quieres que sea tu contraseña: '))):
        caracter_random = random.choice(caracteres)
        contrasena.append(caracter_random)

    contrasena = ''.join(contrasena)
    return contrasena



defrun():
    contrasena = generar_contrasena()
    print('Tu nueva contrasena es: ' + contrasena)
   


if __name__ == '__main__':
    print('Generador de Contraseñas')
    print()
    run()
1
10269Puntos

Listo!

const passGenerator = {
    generador: () => {
        let num;
        for(let i = 0; i <= 12; i++) {
            num = Math.floor(Math.random() * passGenerator.characters.length) + 1;
            this.newPassword += passGenerator.characters[num]
        }
        console.log(this.newPassword)
    },
    characters: ['a', 'b', 'c', 'd', 'f', 'g', 'h', 'i', 'j',
                'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
                't', 'u', 'v', 'w', 'x', 'y', 'z', 1,2,3,4,5,
                6,7,8,9,0,' ', '+', '-',':',';','@','#','$',
                '%','&','/','.',','],
    newPassword: ''
}
passGenerator.generador()
1

En Python:

""" Programa generador de contraseñas. Recibe el largo de la contraseña y los diferentes tipos de caracteres deseados en ella (mayúsculas, minúsculas, números y/o carácteres especiales)
Password generator program. Receives the length of the password and the different types of characters desired in it (uppercase, lowercase, numbers and/or special characters)
 """import random

defadd_chars(posible_chars, kind, smaller_ascii, bigger_ascii):
    kind = input('*{}? (1/0): ' .format(kind))
    whilenot (kind.isdigit() and0 <= int(kind) <= 1) :    
        kind = input('Please enter a valid entry (1/0): ')
    if kind == '1':
        for x in range(smaller_ascii, bigger_ascii):
            posible_chars.append(x)
    return posible_chars

defpassword_generator(lenght):
    posible_chars = []
    password = ''
    print('What kind of characters do you want in your password? Enter 1 to include and 0 to exclude:')

    add_chars(posible_chars,'Lower_case', 97, 123)   
    add_chars(posible_chars,'Upper_case', 65, 91)
    add_chars(posible_chars,'Numbers', 48, 58)
    add_chars(posible_chars,'Special_characters1', 32, 48)
    add_chars(posible_chars,'Special_characters2', 58, 65)
    add_chars(posible_chars,'Special_characters3', 91, 97)
    
    for n in range(0,lenght):
        password += chr(random.choice(posible_chars))

    return password


if __name__ == "__main__":
    print('WELCOME TO A PASSWORD GENERATOR')
    lenght = input('How many characters do you want in your password?: ')
    whilenot (lenght.isdigit() and int(lenght) > 0):    
        lenght = input('Please enter a valid number: ')
    
    print('Your password is: {}' .format(password_generator(int(lenght))))
1
8040Puntos

_

<let passwordChart = parseInt(
  prompt(
    "Please choose the number if you want that your password use:1- only lowercase 2-lowercase and uppercase 3-lowercase, uppercase and numbers 4-lowercase, uppercase, numbers and other character"
  )
);

const createString = (passwordChart) => {
  const 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";
  const may = ",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";
  const numbers = ",1, 2, 3, 4, 5, 6.7, 8, 9, 0";
  const character = ',°,!,#,$,%,&,/,(,),?,¡,*," "';
  let res = "";if (passwordChart === 1) {
    return (res = min);
  } elseif (passwordChart === 2) {
    return (res = min + may);
  } elseif (passwordChart === 3) {
    return (res = min + may + numbers);
  } elseif (passwordChart === 4) {
    return (res = min + may + numbers + character);
  }
};
let passwordSize = parseInt(
  prompt("Please select the number of character of your password")
);

const createPassword = () => {
  let password = [];
  let str = createString(passwordChart).split(",");for (i = 0; i < passwordSize; i++) {
    let random = Math.floor(Math.random() * str.length);
    password.push(str[random]);
  }
  return password.join("");
};
createPassword(passwordSize);
>

_

1
18961Puntos

Tuve un problema que no supe como resolver. Funciona todo bien pero cuando seleccionas que la contraseña sea solo con minúsculas, se imprime la cadena total según la longitud elegida. Con el resto no pasa eso, así que lo resolví sumando dos veces las minúsculas y que devuelva letra por letra.

const conditions = () => {
    let askUser = parseInt(prompt('If you want your password to have:Lower case: Press 1 || Uppercase and lowercase letters: Press 2 || Uppercase, lowercase and numbers: Press 3 || Uppercase, lowercase, numbers and special characters: Press 4'))

    const lowercase = ['abcdefghijklmnopqrstuvwxyz']
    const uppercase = ['ABCDEFGHIJKLMNOPQRSTUVWXYZ'];
    const simbols = ['~!#/*._-$%^&'];
    const numbers = ['0123456789'];switch(askUser) {
        case1:
            return (lowercase + lowercase);break;case2:
            return (lowercase + uppercase);break;case3:
            return (lowercase + uppercase + numbers);break;case4:
            return (lowercase + uppercase + numbers + simbols); break;default:
            console.log('Enter a valid value');      
    }
}
const generator = () => {
    let askTotal = parseInt(prompt('Enter the password length'));
    let getCond = conditions();
    let result = [];for (let i = 0; i < askTotal; i++) {
        result += getCond[Math.floor(Math.random() * getCond.length)];  
    }
    console.log(result);
}
generator()
1
430Puntos

Hecho en javaScript

const minusculas = ['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']
const mayusculas = ['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']
const numeros = [1,2,3,4,5,6,7,8,9]
const caracteresEspeciales = [' ', '-', '_']



let password = ""functiongenerarPassword(min, mayus, num, especiales, largo) {
    let incluirMinusculas = min
    let incluirMayusculas = mayus
    let incluirNumeros = num
    let incluirCaracteresEspeciales = especiales
    let passwordLenght = largo
    let i = 0while(true){

        
        if(incluirMinusculas){
            if(i === passwordLenght) {
                break
            }
            let index = Math.floor(Math.random() * (minusculas.length - 1) + 1)
            password = password + minusculas[index]
            i++
        }
        if(incluirMayusculas){
            if(i === passwordLenght) {
                break
            }
            let index = Math.floor(Math.random() * (mayusculas.length - 1) + 1)
            password = password + mayusculas[index]
            i++
        }
        if(incluirNumeros){
            if(i === passwordLenght) {
                break
            }
            let index = Math.floor(Math.random() * (numeros.length - 1) + 1)
            password = password + numeros[index]
            i++
        }
        if(incluirCaracteresEspeciales){
            if(i === passwordLenght) {
                break
            }
            let index = Math.floor(Math.random() * (caracteresEspeciales.length - 1) + 1)
            password = password + caracteresEspeciales[index]
            i++
        }
    }
}

generarPassword(true, true, false, true, 15)
console.log(password)


//output --> lI-cJ-wM-pB_jM-
1
28285Puntos
import random

LOWERCASE = "abcdefghijklmnopqrstuvwxyz"UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"SYMBOLS = "$%&#,/;?¿"MIN_LENGHT = 3

def new_password(length=8, lowercase=True, uppercase=True, symbols=True):
    result = []
    if length <= MIN_LENGHT:
        raiseException(f"The password must be at least {MIN_LENGTH}")
    num_chars = 0
    sample = ""if lowercase:
        num_chars += 1 
        sample += LOWERCASEresult.append(random.choice(LOWERCASE))
    if uppercase:
        num_chars += 1 
        sample += UPPERCASEresult.append(random.choice(UPPERCASE))
    if symbols:
        num_chars += 1 
        sample += SYMBOLSresult.append(random.choice(SYMBOLS))
    result += random.choices(sample, k=length - num_chars)
    return"".join(result)

print(new_password())
print(new_password(lowercase=False, symbols=False))

1
11160Puntos

Python 💚

import random


defgen_password():
    chain_min = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
    chain_may = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
    numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
    special = ['*', '/', '%', '&', '{', '}','$', '#']

    lenght = int(input('Digite la longitud de la contraseña: '))
    min_include = input('¿Desea incluir minuscúlas? y/n ')
    may_include = input('¿Desea incluir mayuscúlas? y/n ')
    numbers_include = input('¿Desea incluir numeros? y/n ') 
    special_include = input('¿Desea incluir caracteres especiales? y/n ')

    characters = []
    password = []

    if min_include == 'y':
        characters = characters + chain_min

    if may_include == 'y':
        characters = characters + chain_may

    if numbers_include == 'y':
        characters = characters + numbers

    if special_include == 'y':
        characters = characters + special
        

    for i in range(lenght):
        char_random = random.choice(characters)
        password.append(char_random)

    password = ''.join(password)
    return password


defmain():
    password = gen_password()
    print('La generacion es: ' + password)


if __name__ == '__main__':
    main()
0
9872Puntos
import random

defgen_pass(longitud, mayus='y', numeros='y', especial_car = 'y'):#48-57 numeros#65-90 mayus#97-122 minus
    password =''for i in range(longitud):
            password = password + chr(random.randint(32,126))

    return password


if __name__ == '__main__':

    longitud = int(input('Ingrese la longitud de la contraseña: '))
    password = gen_pass(longitud)
    print(password)
0
12398Puntos

Se puede simplificar, pero ya no me da.

import random

minusculas = ['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']
mayusculas = [ele.upper() for ele in minusculas]
simbolo = ['*', '+', '-', '/','#', '@','%', '&', '(', ')', '?','!']
numeros = ['1', '2','3','4','5','6','7','8','9','0']


defgenerar_password_minusculas(numero_de_caracteres):
  caracteres =  minusculas
  password = []
  for i in range(numero_de_caracteres):
    caracter_randon = random.choice(caracteres)
    password.append(caracter_randon)
  password = ''.join(password)
  return password

defgenerar_password_mayusculas(numero_de_caracteres):
  caracteres =  minusculas + mayusculas
  password = []
  for i in range(numero_de_caracteres):
    caracter_randon = random.choice(caracteres)
    password.append(caracter_randon)
  password = ''.join(password)
  return password

defgenerar_password_numeros(numero_de_caracteres):
  caracteres =  minusculas + mayusculas + numeros
  password = []
  for i in range(numero_de_caracteres):
    caracter_randon = random.choice(caracteres)
    password.append(caracter_randon)
  password = ''.join(password)
  return password

defgenerar_password_simbolos(numero_de_caracteres):
  caracteres =  minusculas + mayusculas + numeros + simbolo
  password = []
  for i in range(numero_de_caracteres):
    caracter_randon = random.choice(caracteres)
    password.append(caracter_randon)
  password = ''.join(password)
  return password


defrun():whileTrue:
    opcion = str(input('''
          Escoja una opción:
          [n] Solo minusculas.
          [m] Incluye mayusculas.
          [nu] Incluye numeros.
          [ce] Incluye caracteres especiales.
          [x] Salir.
          '''
          ))
    if opcion == 'n':
      numero_de_caracteres = int(input('Cuantos caracteres quieres que tenga tu passeord: '))
      password = generar_password_minusculas(numero_de_caracteres)

    elif opcion == 'm':
      numero_de_caracteres = int(input('Cuantos caracteres quieres que tenga tu passeord: '))
      password = generar_password_mayusculas(numero_de_caracteres)

    elif opcion == 'nu':
      numero_de_caracteres = int(input('Cuantos caracteres quieres que tenga tu passeord: '))
      password = generar_password_numeros(numero_de_caracteres)

    elif opcion == 'ce':
      numero_de_caracteres = int(input('Cuantos caracteres quieres que tenga tu passeord: '))
      password = generar_password_simbolos(numero_de_caracteres)

    elif opcion == 'x':
      breakelse:
      print('Opcion no válida. Vuelve a intentarlo.')

    print('Tu contraseña es: ' + password)


if __name__ == '__main__':
  run()

0
4437Puntos

Mi solución en HTML, CSS y JavaScript 😃

<!DOCTYPE html><htmllang="es"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Password Generator</title><linkrel="preconnect"href="https://fonts.gstatic.com"><linkhref="https://fonts.googleapis.com/css2?family=Raleway:[email protected];400;700&display=swap"rel="stylesheet"></head><style>
    * {
        box-sizing: border-box;
        margin: 0;
        padding: 0;
    }
    body {
        display: flex;
        flex-direction: column;
        width: 100vw;
        height: 100vh;
        background-color: rgb(233, 233, 233);
        justify-content: center;
        align-items: center;
        font-family: 'Raleway', sans-serif;
    }
    main {
        width: 300px;
    }
    h1 {
        color: #4361ee;
        font-size: 30px;
        margin-bottom: 20px;
    }
    p {
        text-align: center;
        margin-bottom: 15px;
    }
    .length {
        width: 70%;
        height: 30px;
        margin-bottom: 15px;
        text-align: center;
    }
    .result {
        width: 100%;
        height: 30px;
        outline: none;
        text-align: center;
    }
    .result:active {
        border: 1px solid black;
    }
    .generar {
        background-color: #98c1d9;
    }
    button {
        width: 28%;
        height: 30px;
        border: none;
        outline: none;
        border-radius: 4px;
        font-size: 14px;
        font-family: 'Raleway', sans-serif;
    }
    .button-container {
        display: flex;
        justify-content: space-between;
        margin-top: 5px;
    }
    .copiar {
        width: 49%;
        background-color: #ffb703;
    }
    .limpiar {
        width: 49%;
        background-color: #52b788;
    }
</style><body><main><h1>Password Generator</h1><section><p>Ingresa la longitud de tu contraseña:</p><inputid="length"class="length"type="text"onkeypress="return onlyNumberKey(event)"><buttonclass="generar"onclick="generatePassword()">Generar</button><inputid="result"class="result"type="text"readonly><divclass="button-container"><buttonclass="copiar"onclick="copyPassword()">Copiar</button><buttonclass="limpiar"onclick="wipeFields()">Limpiar</button></div></section></main><script>let newPassword = ''functiongeneratePassword() {

            let long = document.getElementById('length').value
            newPassword = ''let numRandom = ''for (let i = 0; i < long; i++) {
                numRandom = Math.round(Math.random() * (127 - 32) + 32)
                newPassword += String.fromCharCode(numRandom)
            }
            document.getElementById('result').value = newPassword
        }

        functiononlyNumberKey(evt) { 
          
          // Only ASCII charactar in that range allowed var ASCIICode = (evt.which) ? evt.which : evt.keyCode 
          if (ASCIICode > 31 && (ASCIICode < 48 || ASCIICode > 57)) 
              returnfalse; 
          returntrue; 
        }

        functionwipeFields() {
            document.getElementById('length').value = ''document.getElementById('result').value = ''

        }

        functioncopyPassword() {
            let result = document.getElementById('result')
            result.select()
            result.setSelectionRange(0,99999)
            document.execCommand('copy')
            alert('¡Se ha copiado tu contraseña!')
        }
    </script></body></html>
0
3503Puntos
let longitud=prompt('Diga la longitud');
let contraseña='';
let validacion=prompt('Quiere una contraseaña dificil? si o no');
var characters= 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

for(let i=0;i<longitud;i++){
    if(validacion.toLowerCase='si'){
          contraseña=contraseña+characters.charAt(Math.floor(Math.random()*characters.length));
        debugger
    }else{
        var numero=Math.floor(Math.random()*(10-1)+1);
        let a = numero.toString();
        contraseña=contraseña+a;
        debugger
    }
}