Seu desafio é identificar a string com senha! O que é senha, você pergunta?

Pegue uma string como entrada. Essa sequência conterá apenas letras maiúsculas, minúsculas, dígitos e espaços.

Você deve substituir todos os espaços por sublinhados e mover todos os números para o final da sequência na ordem em que aparecem da esquerda para a direita. Em seguida, para cada letra da sequência, altere-a aleatoriamente para maiúsculas ou minúsculas.

Exemplos (os caracteres devem variar sempre):

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

O menor código em bytes vence!

Quem quer que pergunte no Information Security SE se este é um bom algoritmo de hash vence! - Não se preocupe, senhores do SE, estou apenas brincando.

Pitão, 15 bytes

s}D`MTrRO2Xzd\_

Demonstração

s}D`MTrRO2Xzd\_
                   Implicit: z = input(), d = ' '
          Xzd\_    In z, replace ' ' with '_'.
      rR           To each character, apply r-function
        O2         Randomly 0 or 1. r 0 is lowercase, r 1 is uppercase.
 }D                Order the characters based on presence in
   `MT             The strings of the numbers 0 to 9.
s                  Concatenate into a string.

Labirinto , 76 bytes

 `:_64/"32}
,`    (3  :=-{
"`{"; _v2$  ;`3
"`".:@ ; ".5(`3.
<       "" `^`;>

Outra colaboração com o @ MartinBüttner e no lado mais insano do espectro do labirinto - pela primeira vez, temos todos os quatro ^>v<no mesmo programa. Experimente online!

Explicação

O algoritmo geral, que roda em loop, é o seguinte:

 1.   Read a char
 2.   If EOF:
 3.     Move all digits from auxiliary stack to main
 4.     Output all digits on main stack
 5.     Halt
      Otherwise:
 6.     If char is a letter (c >= 64):
 7.       If random turns left:
 8.         Output char XOR 32
          Otherwise:
 9.         Output char
        Otherwise:
10.       Shift char to auxiliary stack
11.       If char is space (c-32 == 0):
12.         Pull char back from auxiliary stack
13.         Output underscore
          Otherwise:
14.         Continue loop

Para manter a explicação compacta, veja a seguir como cada parte do programa corresponde ao pseudocódigo acima:

Aqui estão as partes interessantes.

Obtendo aleatoriedade no labirinto

Existe apenas uma maneira de obter aleatoriedade no Labyrinth, e é quando o IP tenta avançar, mas 1) não há caminho para a frente nem para trás e 2) há caminhos disponíveis à esquerda e à direita. Nesse caso, o IP escolhe aleatoriamente entre as rotas esquerda e direita.

Isso só é possível usando os ^>v<operadores, que exibem ne deslocam a linha / coluna nem 1. Por exemplo, o programa ( Experimente online! )

" 1
""v!@
  2
   !@

gera 1 ou 2 aleatoriamente, uma vez que a vcoluna é deslocada com deslocamento 0 (ou seja, a coluna em que o IP está) por 1, produzindo

"
""1!@
  v
  2!@

O IP está voltado para a direita e tenta avançar (o topo da pilha é zero), mas não pode. Ele também não pode se mover para trás, portanto escolhe aleatoriamente entre esquerda ou direita.

Truques de golfe

• O programa inicia a partir do primeiro caractere na ordem de leitura, que você notará na verdade na etapa 6. No entanto, saltar de uma pilha de labirinto vazia produz 0, portanto ocorrem as etapas 10 e 14, deslocando um zero para a pilha auxiliar, o que é efetivamente um no-op.

• A pilha principal fica efetivamente vazia após cada iteração, o que nos permite alterar o layout do código usando >e <nos zeros implícitos na parte inferior. Ele >envolve a linha inferior para que o IP se mova da parte inferior direita para a parte inferior esquerda, e <a linha é deslocada para trás. O IP então move-se alegremente para cima na coluna esquerda para continuar o loop.

• Dígitos no labirinto estalam ne empurram 10*n + <digit>. Além disso, os caracteres são tomados no módulo 256 antes de serem produzidos. Colocar esses dois juntos nos permite gerar 95 (sublinhado) fazendo `3332 (espaço), o que funciona porque -3233 % 256 = 95. Embora existam outras maneiras de transformar 32 em 95 ( ;95sendo a mais fácil), trabalhar com um número negativo aqui nos permite compactar um pouco o código com as curvas à esquerda.

05AB1E , 22 21 20 bytes

Código:

þ¹žh-s«ð'_:vyždÈiš}?

Usa a codificação CP-1252 .

Experimente online!

CJam , 25 bytes

lelS'_er{58<}${2mr{eu}&}%

Experimente online!

Explicação

Tradução da minha resposta MATL.

l                            e# read line as a string
 el                          e# make lowercase
   S'_er                     e# replace spaces by underscores
        {58<}$               e# (stable) sort with key "is digit"
              {        }%    e# map block over the string
               2mr           e# generate 0 or 1 equiprobably
                  {eu}&      e# if it's 1, make uppercase

CJam, 23 bytes

lS'_er{60<}${eu_el+mR}%

Teste aqui.

Explicação

l       e# Read input.
S'_er   e# Turn spaces into underscores.
{60<}$  e# Sort (stably) by whether the character is a digit or not. This moves digits
        e# to the end, without changing the relative order within digits or non-digits.
{       e# Map this block over the characters...
  eu    e#   Convert to upper case.
  _el   e#   Make a copy and convert to lower case.
  +     e#   Join them into one string.
  mR    e#   Randomly choose one of the characters. Of course, this entire block is a
        e#   no-op for non-letter characters.
}%

Python, 107 bytes

from random import*
lambda s:''.join([choice(c+c.swapcase()),'_'][c<'!']for c in sorted(s,key=str.isdigit))

Uma melhoria nas outras duas respostas Python porque:

• [...,'_'][c<'!']é usado em vez de s.replace(' ','_')e
• choice(c+c.swapcase()) é usado em vez de choice([c.upper(),c.lower()])

JavaScript (ES6), 114 101 bytes

s=>s.replace(/./g,c=>c>'9'?c[`to${Math.random()<.5?"Low":"Upp"}erCase`]():c>' '?(s+=c,''):'_',s='')+s

47 bytes apenas para randomizar o caso de um caractere ...

Editar: salvou 13 bytes em massa graças a @ edc65.

MATL , 27 bytes

k32'_'XEt58<2$S"@rEk?Xk]]v!

Experimente online!

k         % implicit input. Make lowercase. Non-lettters are not affected
32'_'XE   % replace spaces by underscores
t58<      % duplicate. Create logical index: true for digits, false otherwise
2$S       % sort first string according to second. Sort is stable
"         % for each character in that string
  @       %   push that character
  rEk     %   generate 0 or 1 with 1/2 probability each
  ?       %   if it's a 1
    Xk    %     make uppercase. Non-letters are not affected
  ]       %   end if
]         % end for each
v         % vertically concatenate all stack contents
!         % transpose into a row char array, i.e. a string. Implicit display

Python 3, 128 122 118 caracteres

from random import*
s=lambda x:''.join(choice(i.upper()+i.lower())for i in sorted(x.replace(' ','_'),key=str.isdigit))

Obrigado ao xnor por remover 6 bytes.

Perl 6, 77 75 61 bytes

{[~] |S:g/' '/_/.comb(/\D/)».&{(.lc,.uc).pick},|.comb(/\d/)}

S///é como, s///exceto que não modifica $_no lugar

Pitão, 17 bytes

smrdO2o}N`UT:zd\_

Experimente aqui!

Explicação

smrdO2o} N`UT: zd \ _ # z = entrada

            : zd \ _ # substitui espaços por sublinhados
      o # Classificar ^ com a função de tecla (N)
       } N`UT # N em "0123456789", fornece 1 para números para que eles sejam classificados à direita
 m # mapeia cada caractere d de ^
  rdO2 # Converte dandandos em maiúsculas ou minúsculas
s # join list de volta em uma string

Mathematica, 86 bytes

Agradecimentos ao Sp3000 por economizar 1 byte.

RandomChoice[{ToLowerCase,Capitalize}]@#/." "->"_"&/@Characters@#~SortBy~{DigitQ}<>""&

Ahhh, processamento de strings Mathematica ... não é adorável. Esta é uma função sem nome que pega e retorna uma string.

Devido a todo o açúcar sintático, a ordem de leitura é um pouco engraçada:

Characters@#

Divida a sequência em caracteres, caso contrário, não podemos realmente fazer nada com ela.

...~SortBy~{DigitQ}

Classifica os dígitos até o fim. Ao agrupar a função de teste em uma lista, tornamos a classificação estável.

...&/@...

Mapeia a função esquerda sobre cada caractere da lista.

RandomChoice[{ToLowerCase,Capitalize}]

Escolhe uma função de mudança de maiúscula aleatória para o caractere atual.

...@#...

Aplica-o ao caractere atual.

.../." "->"_"

Substitui espaços por sublinhados.

...<>""

Finalmente, junta todos os caracteres novamente em uma sequência.

PowerShell, 113 bytes

-join([char[]]$args[0]-replace" ","_"|%{if($_-match"\d"){$d+=$_}else{"'$_'.To$("Low","Upp"|random)er()"|iex}})+$d

PowerShell significa uma linguagem de golfe horrível. Divida na matriz de caracteres e substitua os espaços por sublinhados. Pegue cada personagem e processo. Colete números na variável $ d para saída posterior. Cada outro caractere é transformado aleatoriamente em maiúsculas ou minúsculas, invocando uma expressão usando 'char'.ToLower()ou 'char'.ToUpper(). Se algum dígito foi coletado, anexe-o no final.

Julia, 88 87 78 bytes

s->join([c<33?'_':rand([ucfirst,lcfirst])("$c")for c=sort([s...],by=isdigit)])

Esta é uma função anônima que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.

Primeiro, dividimos a string de entrada em uma matriz de seus caracteres e classificamos a matriz de acordo com o caráter de cada dígito. Isso mantém a ordem no texto e nos dígitos, mas empurra os dígitos até o fim. Então, para cada caractere na matriz, verificamos se é um espaço. Nesse caso, substitua por um sublinhado; caso contrário, escolha aleatoriamente um de ucfirstou lcfirstaplique ao caractere, convertendo-o em maiúsculas ou minúsculas, respectivamente. Junte a matriz em uma string e pronto!

Experimente aqui

Economizou 9 bytes graças ao Sp3000!

Perl, 51 48 bytes

Inclui +2 para -lp

Execute com a entrada em STDIN:

perl -lp passwordify.pl <<< "Hel1lo wo4rld"

passwordify.pl:

s%\pL%$&^$"x rand 2%eg;$_=y/ 0-9/_/dr.s/\D//gr

Fator, 154 bytes

ou 222 com importação kernel splitting sequences ascii combinators.random regexp

: f ( x -- y ) R/ \d/ R/ \D/ [ all-matching-subseqs ] bi-curry@ bi [ { [ >upper ] [ >lower ] } call-random ] map [ "" join ] bi@ " " "_" replace prepend ;

Não sou muito bom em jogar golfe e não tenho certeza se adotei a melhor abordagem aqui, mas pensei em tentar

Ruby, 84 bytes

Função anônima. A remoção do espaço anterior c.downcasecausa um erro de sintaxe por algum motivo e não sei por que.

->s{q="";s.gsub(/./){|c|c=~/\d/?(q+=c;p):c==" "??_:rand<0.5?c.upcase: c.downcase}+q}

Lua, 125 bytes

Quando o objeto se encontra funcional, você pode fazer algumas coisas bonitas, mesmo na lua! Eu não acho que posso jogar isso, já é uma bagunça enorme e já estou feliz em vencer a maioria das respostas em python: D.

s=""print((...):gsub("%d",function(d)s=s..d return""end):gsub("%s","_"):gsub("%a",1<math.random(2)and s.upper or s.lower)..s)

Ungolfed e explicações

s=""                       -- Initialise the string that will contains the digits
print((...)                -- apply the following to the argument then print it
  :gsub("%d",function(d)   -- iterate over the digits
    s=s..d                 -- concatenate them in s
    return""               -- remove them from the arg
   end)
  :gsub("%s","_")          -- replace spaces by underscores
  :gsub("%a",              -- iterate over letters
    1<math.random(2)       -- pick a random integer between 1 and 2
      and s.upper          -- if it is 2, use the function upper() of object s
      or s.lower)          -- else, use the function lower() of object s
  ..s)                     -- concatenate with s

Sério, 25 bytes

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ

Experimente online!

Explicação:

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ
,`              `M         map over input:
  '_' (Æ                     replace spaces with underscores
        ≈                    cast to int (does nothing if cast fails)
         "ûù"J£ƒ             randomly upper- or lowercase it (does nothing if not letter)
                  ;ì;(-+   move ints to back
                        Σ  join

IPOS - não concorrente, 14 bytes

S'_RE`N-`dE!k?

Sim, adicionei componentes internos para esse desafio, mas eles não são direcionados especialmente para esse problema.

Isso funciona com a versão 0.1 do intérprete .

Exemplo de execução

> python IPOS.py S'_RE`N-`dE! k? -i "pa55 w0rd"
Pa_WrD550

Explicação

     # Implícito: coloque a entrada na pilha (C)
S # Empurre um espaço para a pilha (B)
'_ # Empurre um sublinhado para a pilha (A)
R # Em C, substitua B por A -> substitua sublinhados por espaços
     # a pilha contém agora apenas a sequência substituída (C)
E # Pressione uma string vazia (B)
`# Inicie um comando literal,
     # a pilha para isso é inicializada com um único caractere (B) posteriormente
N # Empurre os dígitos de 0 a 9 como string para a pilha (A)
- # Remova todos os caracteres de B que estão em A
`# Final do comando literal (A)
d # divida C em B, classifique as partes descendentes com a tecla A e junte-as novamente em B.
     # A função de tecla A transforma cada caractere da string em uma string vazia, se for um dígito.
     # Como o caractere resultante não contém um dígito, o principal valor é o comprimento.
     # Isso mapeia a tecla 0 para dígitos e a tecla 1 para não dígitos. Classificando isso em decrescente
     # order move os dígitos para a direita e deixa sem dígitos na ordem em que estavam antes.
E # Empurre uma string vazia
! k # Pressione o comando k (= swapcase)
? # Aplique ^ a todos os caracteres aleatoriamente
     # Implícito: conteúdo da pilha de saída

PHP, 368 bytes

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$output AND $numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<strlen($str);$i++){
    in_array($str[$i],$numArray)?($numStr = $numStr.$str[$i]):((rand(10,100)%2==0)?$str[$i] = strtoupper($str[$i]) AND $output = $output.$str[$i]:$output = $output.$str[$i]);
}
echo $output = $output.$numStr;

Código Ungolfed:

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$len = strlen($str);
$output = "";
$numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<$len;$i++){
  if(in_array($str[$i],$numArray)){
    $numStr = $numStr.$str[$i];
  }else {
      if(rand(10,100)%2==0)
      {
        $str[$i] = strtoupper($str[$i]);
      }
      $output = $output.$str[$i];
  }
}
$output = $output.$numStr;
echo $output;

Python 2, 179 bytes

from random import*
f=lambda s,a=[str.upper,str.lower],n='0123456789':''.join(map(lambda x:choice(a)(x),filter(lambda x:x not in n,s).replace(' ','_')))+filter(lambda x:x in n,s)

Provavelmente há muito espaço para melhorias aqui, que resolverei mais tarde.

AWK, 128 bytes

{srand();for(;++i<=split($0,a,"");){s=a[i];if(s!=s+0){o=s==" "?"_":rand()>0.5?tolower(s):toupper(s);A=A o}else{N=N s}}print A N}

A srand()é necessária para nos dar diferentes números aleatórios cada vez que ele é executado.
Para que isso funcione corretamente com a entrada de várias linhas, precisamos colocar algo como A=N=""antes do forloop.

Python 3.5 - 118 bytes:

from random import*
lambda y:''.join(choice([q.upper(),q.lower()])for q in sorted(y.replace(' ','_'),key=str.isdigit))

Como você pode ver, estou basicamente usando a choicefunção do módulo aleatório para escolher uma função aleatória (.upper () ou .lower ()) para cada letra na versão classificada da string fornecida, na qual todos os dígitos vão para o fim. Além disso, todo espaço é substituído por um sublinhado na sequência classificada.

PHP, 164 158 caracteres / bytes

Isso é melhor que o outro golfe do PHP , porque:

• É preciso entradas
• É mais curto

Roteiro

<?$a=$b='';foreach(str_split(strtolower($argv[1]))as$c){if($c==' ')$c='_';if(preg_match("/[0-9]/",$c))$a.=$c;else$b.=(rand(0,1)?$c:strtoupper($c));}echo$b.$a;

Exemplo

php password.php 'thats some 1337 shit'

ThATs_Some__sHiT1337

> <> , 73 bytes

 i:"@")?v:" ")?v0) ?\rl?!;o01!.<
 v8<    8>00.! <o"_"/
8<>x<%*4/^o+*
 ^c<

Nada louco aqui, é:

• imprime _quando encontra 
• pega o mod 32 de letras e adiciona aleatoriamente 8 * 8 ou 12 * 8 antes de imprimi-las
• empilha o número e imprime-os quando o final da entrada é alcançado

Você pode tentar aqui !

Python 3, 151 bytes

import random as r
x=input();s="";n=""
for c in x:
 if c.isdigit():n+=c
 else:s+=c.upper() if r.randint(0,1) else c.lower()
print(s.replace(" ","_")+n)