4

#PlatziCodingChallenge - Generador de IPs

Una IP se compone de 4 números separados por un punto (.) y estos van del 0 al 255. Debes crear un programa que genere IPs de forma aleatoria con estas características (ejemplo: 1.127.0.231), puedes indicarle que genere 1000 distintas y depués validar si se repite alguna o listarlas en orden ascendiente.

Escribe tu comentario
+ 2
Ordenar por:
2
4648Puntos

mi implementacion en python 3.8

import random 

defgen_ip(quant=1000): 
    ran=lambda x:  random.randint(0,  x)# get subgroups 
    list_ips=[]
    for i in  range(quant): # get 1000 ips
        ip = "".join([str(ran(255))+"."if _ !=3else str(ran(255)) for _ in range(4)])
        while  ip in list_ips : 
            # validate only uniques ips
            ip ="".join([str(ran(255))+"."if _ !=3else str(ran(255)) for _ in range(4)])  
        list_ips +=[ip]
        
    # create a number replacing dots and converting to integer to form  a dictionary#      then compare this results
    temp = {int(i.replace(".", "")):i for i in list_ips}
    list_ips=dict(sorted(temp.items()))
 
    return list(list_ips.values())# return only uniques values

print((a:= gen_ip()), len(a))
1
4648Puntos
6 meses

solo devuelve ips unicas y ordenadas de acuerdo a la magnitud de su numero total como conjunto

2
7689Puntos

Resultado:

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

  .contenedor {
    width: 100%;
    height: 100vh;
    min-width: 750px;
    display: flex;
    justify-content: center;
    align-items: center;
    flex-flow: column;
  }

  .contenedorh1 {
    margin-bottom: 36px;
  }

  .inputs {
    font-size: 18px;
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
  }

  .section {
    margin-bottom: 36px;
  }

  .btn {
    margin: 8px;
    border-radius: 15px;
    outline: none;
    font-size: 24px;
    border: solid 1px black;
    color: #000504;
    text-align: center;
    padding: 16px;
    margin-bottom: 36px;
  }

  .btn:hover {
    cursor: pointer;
    background-color: rgba(0, 0, 0, 0.397);
    color: white;
    transform: scale(1.1);
  }
  
  #resultado {
    display: flex;
    flex-direction: column;
    align-items: center;
  }
</style><bodyid='body'><divclass="contenedor"><h1>Generador de Ips</h1><divclass="inputs"><sectionclass="section">
        Ingrese la cantidad de Ips que deseas <inputid="límite"/></section></div><buttononclick="generar()"class="btn">Generar...</button><pid='resultado'></p></div><script>functiongenerar(){
      document.getElementById('resultado').innerHTML = ''let limite = document.getElementById('límite').value
      let ips = []
      for (let i = 0; i < limite; i++){
        let ip = []
        for (let x = 0; x < 4; x++){
          let number = Math.floor(Math.random() * 256)
          ip.push(number)
        }
        if (ips.length === 0){
          ips.push(ip)
        } else {
          let verdadero = false
          ips.forEach( IP => {
            if (JSON.stringify(IP) == JSON.stringify(ip)){
              verdadero = trueconsole.log('repetida')
            }
          })
          if (!verdadero){
            ips.push(ip)
          }
        }
      }
      console.log(ips)
      document.getElementById('resultado').innerHTML = 'Revisa la consola para los resultados'
    }
  </script></body></html>

Lo que el código hace es crear la lista de ips según el largo que tu le especifiques y al crearla revisa que ninguna ip sea igual que las ya existentes en la lista.

1
6282Puntos
let ip = []
let ipList = []
const randomNumbers  = () => Math.round(Math.random() * (255 - 0) + 0)

    for(let i = 0; i < 1000; i++){
        ip = []
            for(let i = 0; i < 4; i++){
                ip.push(randomNumbers())
            }

        readyIp = ip.join('.')
            if(ipList.includes(readyIp)){
                console.log(`${readyIp} repeats`)
            }
        ipList.push(readyIp)
    }
1
27103Puntos

Implementación en Python usando argumentos 😃

from argparse import ArgumentParser
from random import getrandbits


classInterface:def__init__(self):
        args = ArgumentParser()
        args.add_argument('quantity', type=int)
        args.add_argument('-s', '--sort', action='store_true')
        args.add_argument('-nr', '--no-repeat', action='store_true', dest='nr')
        args.add_argument('-o', '--output-file', default=None, dest='o')
        self.args = args.parse_args()

    def__gen_ip(self):return".".join([str(getrandbits(8)) for _ in range(4)])

    def__get_ip_list(self):if self.args.quantity < 0:
            raise RuntimeError('Please use a positive valor')
        return [self.__gen_ip() for _ in range(self.args.quantity)]

    def__write_output_file(self, ip_list):with open(self.args.o, 'w') as fp:
            stamp = '\n'.join(ip_list)
            fp.write(stamp)

    defmain(self):
        ips = self.__get_ip_list()
        if self.args.sort:
            ips = sorted(ips)
        if self.args.nr:
            ips = set(ips)

        if self.args.o isNone:
            for ip in ips:
                print(ip)
        else:
            self.__write_output_file(ips)
            
    
#  Main execution if __name__ == "__main__":
    Interface().main()


#  Examples#  python ipgen.py 1000#  python ipgen.py 1000 -nr -s#  python ipgen.py 1000 --no-repeated --output-file ips.txt#  python ipgen.py 7 --sort
1
19943Puntos

Reto 45: Generador de IPs en JavaScript

// Generador de IPs en JavaScript// Genera un solo IPfunctionIPGenerator() {
  const numbers = newArray()
  for (let i = 0; i < 4; i++) {
    numbers.push(Math.floor(Math.random() * 256))
  }
  const IP = numbers.join('.')
  return IP
}

// Genera n IPsfunctiongenerateIPs(n) {
  const IPs = newArray()
  for (let i = 0; i < n; i++) {
    IPs.push(IPGenerator())
  }
  return IPs
}

// Ordena una lista de IPsfunctionsortIPs(IPs) {
  return IPs.sort((a, b) => parseInt(a.split('.').join()) - parseInt(b.split('.').join()))
}

// Encuentra el número de IPs repetidosfunctionrepeatedIPs(IPs) {
  return IPs.length - newSet(IPs).size
}

const misIPs = generateIPs(1000)
console.log(misIPs)
const misIPsOrdenados = sortIPs(misIPs)
console.log(misIPsOrdenados)
const IPsRepetidos = repeatedIPs(misIPs)
console.log(IPsRepetidos)
1

En Python 😃 Primero ordena el diccionario que contiene las ips y en caso de haber repetido alerta al usuario y vuelve a generar otra secuencias de ips de manera aleatoria y finalmente imprime las ip de manera ordenada

import random
defmensaje():
    print('Hay ip repetida volviendo a generar')
    main()

defmain():
    ips=[]
    for i in range(1000):
        ip=[]
        ip1=random.randint(0,255)
        ip.append(ip1)
        ip2=random.randint(0,255)
        ip.append(ip2)
        ip3=random.randint(0,255)
        ip.append(ip3)
        ip4=random.randint(0,255)
        ip.append(ip4)
        ips.append(ip)
    ips=sorted(ips)
    imprimir(ips)

defimprimir(ips):for y in ips:
        cont=0for z in ips:
            if y==z:
                cont=cont+1else:
                passif cont==2:
                mensaje()
            else:
                passfor x in ips:
        print(f'{x[0]}.{x[1]}.{x[2]}.{x[3]}')
if __name__ == '__main__':
    main()```