Crie palavras não aleatórias [closed]

Question

dd if=/dev/urandom of=a.log bs=1M count=2

Pergunta: se este código ^ me der números aleatórios, como posso obter não-palavras aleatórias (ininteligíveis) como "hgcqw".

Pergunta 2: O comando shuf pode ser usado em conjunto com o comando dd?

Obrigado!

6/21 Atualização. (Dia dos pais)

@ Serg Meu objetivo era obter números no começo. Digamos, números aleatórios de dois dígitos de 01 a 100. Dê o comando e execute o código. Eventualmente, isso me dará 14, 17, 21, 35 (estou inventando quais números aleatórios eu recebo). Em seguida, eu queria obter uma média desses números. Nesse caso, a média seria 21,75 (22). O objetivo seria parar o loop até encontrar uma média específica que eu estava procurando. Nesse caso, seria 25. Meu segundo objetivo era obter palavras aleatórias e depois contar quais palavras foram usadas.

@ terdon

Uma palavra é "fanfarrão", "pato" ou "boa sorte". Basicamente, qualquer coisa encontrada no dicionário. Os comprimentos seriam ainda se limitássemos o limite a 5 letras, não me importaria de aprender como?

O que é uma palavra? Eu presumo que você quer dizer apenas a-z e A-Z, mas que comprimentos? Será que liwyduglashvdbalishfvgapivflakhf seria uma palavra? E que tal o ksjdas-asd-asd-asd? - pode estar em palavras. Por favor edite e esclareça. - Terdon ontem

    

Answer 1

Gere um caractere alfabético aleatório.

tr -cd '[:alpha:]' < /dev/urandom | fold -w1 | head -n1  

Gere uma cadeia alfabética aleatória com 10 caracteres de comprimento.

tr -cd '[:alpha:]' < /dev/urandom | fold -w10 | head -n1

Algumas das classes de caracteres POSIX alternativas a serem usadas, em vez do alpha in [:alpha:] , são: _{alnum - caracteres alfanuméricos
caracteres alfa - alfabéticos
dígito - dígitos
gráfico - personagens visíveis
letras minúsculas - minúsculas
caracteres maiúsculos superiores}

Gere números aleatórios em um intervalo específico (exemplo 1-10).

shuf -i 1-10 -n1  

Comparado aos dois primeiros exemplos, o comando shuf oferece menos opções para gerar strings aleatórias, embora shuf possa ser usado para gerar permutações aleatórias.

    

Answer 2

dd if=/dev/urandom of=a.log bs=1M count=2

Isso não lhe dá números aleatórios. Isto dá-lhe bytes aleatórios. Você poderia codificá-lo para números:

hexdump -v -e '"%d\n"' /dev/urandom | dd of=a.log bs=1M count=2

(A versão anterior usou od , mas o formato de saída de od é bastante inflexível.)

Usar /dev/random diretamente pode ser um pouco desnecessário, já que é um fluxo de bytes. Você pode codificá-lo para base64 e, em seguida, remover os não-alfabetos, o que ainda deve gerar, em média, 80% dos dados de entrada:

base64 /dev/urandom | tr -cd '[[:alpha:][:space:]]'

Isso tende a deixar linhas bastante longas. Você poderia, em vez disso, substituir números por novas linhas:

base64 /dev/urandom | sed 's/[^[:alpha:]]\+/\n/g'

    

Answer 3

Para gerar uma cadeia alfabética aleatória de letras minúsculas (incluindo espaços) de 2MB:

< /dev/urandom tr -dc 'a-z ' | head -c 2000000 > a.log

Para um fluxo constante:

< /dev/urandom tr -dc 'a-z '

Para gerar uma cadeia alfabética aleatória de casos mistos (incluindo espaços) de 2MB:

< /dev/urandom tr -dc 'A-Za-z ' | head -c 2000000 > a.log

Para um fluxo constante:

< /dev/urandom tr -dc 'A-Za-z '

    

Answer 4

Uma outra versão ( -c${1:-10} = comprimento de 10):

< /dev/urandom tr -dc A-Za-z | head -c${1:-10} > out

ou ( head -n 10 = comprimento de 10)

strings /dev/urandom | grep -o '[[:alpha:]]' | head -n 10 | tr -d '\n' > out

ou com dd ( count=10 = comprimento de 10)

dd if=/dev/urandom bs=1 count=10 2>/dev/null | base64 | grep -o '[[:alpha:]]' | head -n 30 | tr -d '\n' > out

ou isto

openssl rand -base64 32| grep -o '[[:alpha:]]' | head -n 10 | tr -d '\n' > out

ou isto

date +%s | sha256sum | base64 | grep -o '[[:alpha:]]'| head -n 10 | tr -d '\n' > out

    

Answer 5

Aqui está a minha ideia. mkpasswd é usado frequentemente para gerar senhas criptografadas, portanto, as cadeias não devem ser inteligíveis. O pequeno problema é que gera strings com números. Ao usar sed, podemos nos livrar deles.

mkpasswd | sed 's/[0-9]/YOLO/g'

O YOLO pode ser o que você quiser substituir por dígitos. Você também pode simplesmente excluí-los:

mkpasswd | sed 's/[0-9]//g'

Aqui está outra maneira:

$ date | md5pass | sed 's/[0-9]//g'                                                                                                   
$$NG.dLw$vcpGCylnDtmptDtogDr/

Como sugerido nos comentários abaixo, você também pode instalar pwgen , com sudo apt-get install pwgen e executar pwgen -0 . O sinalizador -0 diz ao comando para evitar numerais

E aqui está sha1pass + sed combo:

sha1pass | sed 's/[[:digit:]]//g' | sed 's/[[:punct:]]//g'
Resultado: PoXGAlAWjzMHgmfzHiYHGpemzqE

Outro método com variável $ RANDOM: echo $RANDOM | tr '0-9' 'a-z'

No geral, se sua meta for geração de senha, sugiro que você leia este artigo:

link

    

Answer 6

Usando python :

#!/usr/bin/env python2
import random, string 
def rand_gen(number_of_words, length):
    for i in range(number_of_words):
        print ''.join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for _ in range(length))
    return

• Definimos uma função rand_gen(number_of_words, length) que terá dois parâmetros como entradas, number_of_words conterá o número de palavras aleatórias que você deseja gerar, length conterá o comprimento de cada palavra aleatória

• string.ascii_lowercase e string.ascii_uppercase têm todas as letras ASCII em minúsculas e maiúsculas respectivamente

• random.choice escolherá um único caractere de [A-Za-z] a cada vez e length garantirá que essa iteração continue até o número length . join() irá então juntar os caracteres para ter uma palavra de tamanho desejado

• Esse processo continuará até number_of_words

Exemplo:

rand_gen(5, 3)
PDI
qKQ
Dvu
kwr
wDz

rand_gen(2, 5)
GLKXr
uOaHj