¡Su desafío es contraseña la cadena! ¿Qué es la contraseña?

Tome una cadena como entrada. Esta cadena solo contendrá letras mayúsculas, minúsculas, dígitos y espacios.

Debe reemplazar todos los espacios con guiones bajos y mover todos los números al final de la cadena en el orden en que aparecen de izquierda a derecha. Luego, para cada letra de la cadena, cámbiela al azar a mayúsculas o minúsculas.

Ejemplos (el caso de los caracteres debe variar cada vez):

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

¡El código más corto en bytes gana!

¡Quien pregunte en Information Security SE si este es un buen algoritmo de hash gana! - No se preocupe, señores SE, solo bromeo.

Pyth, 15 bytes

s}D`MTrRO2Xzd\_

Demostración

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.

Laberinto , 76 bytes

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

Otra colaboración con @ MartinBüttner y en el lado más loco del espectro Labyrinth: por primera vez, tenemos los cuatro ^>v<en un solo programa. Pruébalo en línea!

Explicación

El algoritmo general, que se ejecuta en un bucle, es el siguiente:

 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 mantener la explicación compacta, aquí es más o menos cómo cada parte del programa corresponde al pseudocódigo anterior:

Aquí están las partes interesantes.

Obteniendo aleatoriedad en el laberinto

Solo hay una forma de obtener aleatoriedad en Labyrinth, y es cuando la IP intenta avanzar pero 1) no hay un camino hacia adelante ni hacia atrás y 2) hay caminos disponibles a izquierda y derecha. En este caso, la IP elige aleatoriamente entre las rutas izquierda y derecha.

Esto solo es posible utilizando los ^>v<operadores, que muestran ny desplazan la fila / columna nen 1. Por ejemplo, el programa (¡ Pruébelo en línea! )

" 1
""v!@
  2
   !@

genera 1 o 2 al azar, ya que vdesplaza la columna con el desplazamiento 0 (es decir, la columna en la que está la IP) en 1, produciendo

"
""1!@
  v
  2!@

La IP está orientada hacia la derecha e intenta avanzar (la parte superior de la pila es cero) pero no puede. Tampoco puede moverse hacia atrás, por lo que elige aleatoriamente entre izquierda o derecha.

Trucos de golf

• El programa comienza desde el primer carácter en el orden de lectura, que notará que en realidad es el paso 6. Sin embargo, al saltar de una pila de Labyrinth vacía se obtiene 0, por lo que se producen los pasos 10 y 14, cambiando un cero a la pila auxiliar, que es efectivamente un no-op.

• La pila principal está efectivamente vacía después de cada iteración, lo que nos permite jugar al diseño del código usando >y <en los ceros implícitos en la parte inferior. La >envuelve la fila inferior alrededor de modo que los movimientos IP desde la parte inferior derecha a la parte inferior izquierda, y los <cambios de la fila de atrás. La IP luego felizmente se mueve hacia arriba en la columna izquierda para continuar el ciclo.

• Los dígitos en Labyrinth explotan ny empujan 10*n + <digit>. Además, los caracteres se toman en el módulo 256 antes de salir. Poniendo estos dos juntos nos permite la salida 95 (subrayado) haciendo `33al 32 (espacio), que funciona porque -3233 % 256 = 95. Aunque hay otras formas de convertir 32 en 95 ( ;95siendo la más fácil), trabajar con un número negativo aquí nos permite compactar un poco el código con giros a la izquierda.

05AB1E , 22 21 20 bytes

Código:

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

Utiliza la codificación CP-1252 .

Pruébalo en línea!

CJam , 25 bytes

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

Pruébalo en línea!

Explicación

Traducción de mi respuesta 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}%

Pruébalo aquí.

Explicación

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))

Una mejora en las otras dos respuestas de Python porque:

• [...,'_'][c<'!'] se usa en lugar de s.replace(' ','_') , y
• choice(c+c.swapcase()) se usa en lugar 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 solo para aleatorizar el caso de un personaje ...

Editar: ahorró 13 bytes masivos gracias a @ edc65.

MATL , 27 bytes

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

Pruébalo en línea!

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))

Gracias a xnor por reducir 6 bytes.

Perl 6, 77 75 61 bytes

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

S///es como, s///excepto que no se modifica $_en su lugar

Pyth, 17 bytes

smrdO2o}N`UT:zd\_

Pruébalo aquí!

Explicación

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

            : zd \ _ # reemplaza espacios con guiones bajos
      o # Ordenar ^ con la función de tecla (N)
       } N`UT # N en "0123456789", da 1 para los números para que se ordenen a la derecha
 m # asigna todos los caracteres d de ^
  rdO2 # Convertir d randoms a mayúsculas o minúsculas
s # unirse a la lista de nuevo en una cadena

Mathematica, 86 bytes

Gracias a Sp3000 por guardar 1 byte.

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

Ahhh, el procesamiento de cadenas de Mathematica ... no es encantador. Esta es una función sin nombre que toma y devuelve una cadena.

Debido a todo el azúcar sintáctico, el orden de lectura es un poco divertido:

Characters@#

Divide la cadena en caracteres, de lo contrario no podemos hacer nada con ella.

...~SortBy~{DigitQ}

Ordena los dígitos hasta el final. Al ajustar la función de prueba en una lista, hacemos que la ordenación sea estable.

...&/@...

Asigna la función de la izquierda sobre cada personaje de la lista.

RandomChoice[{ToLowerCase,Capitalize}]

Elige una función aleatoria de cambio de mayúsculas y minúsculas para el personaje actual.

...@#...

Lo aplica al personaje actual.

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

Reemplaza los espacios con guiones bajos.

...<>""

Finalmente une todos los personajes nuevamente en una cadena.

PowerShell, 113 bytes

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

PowerShell significa lenguaje de golf horrible. Dividir en matriz de caracteres y reemplazar espacios con guiones bajos. Toma cada personaje y proceso. Recopile números en la variable $ d para salida posterior. Cada otro carácter se convierte aleatoriamente en mayúsculas o minúsculas invocando una expresión usando 'char'.ToLower()o 'char'.ToUpper(). Si se recogieron dígitos, agréguelos al final.

Julia, 88 87 78 bytes

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

Esta es una función anónima que acepta una cadena y devuelve una cadena. Para llamarlo, asígnelo a una variable.

Primero, dividimos la cadena de entrada en una matriz de sus caracteres y clasificamos la matriz de acuerdo a si cada carácter es un dígito. Esto mantiene el orden en el texto y los dígitos, pero empuja los dígitos hasta el final. Luego, para cada personaje de la matriz, verificamos si es un espacio. Si es así, reemplácelo con un guión bajo, de lo contrario, elija aleatoriamente uno de ucfirsto lcfirstpara aplicar al carácter, convirtiéndolo en mayúsculas o minúsculas, respectivamente. ¡Únete a la matriz en una cadena y listo!

Pruébalo aquí

¡Guardado 9 bytes gracias a Sp3000!

Perl, 51 48 bytes

Incluye +2 para -lp

Ejecutar con la entrada en STDIN:

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

passwordify.pl:

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

Factor, 154 bytes

o 222 con importación 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 ;

No soy demasiado bueno para jugar golf en factor, y no estoy seguro de si tomé el mejor enfoque aquí, pero pensé en intentarlo.

Ruby, 84 bytes

Función anónima. Eliminar el espacio anterior c.downcasecausa un error de sintaxis por alguna razón y no estoy seguro de por qué.

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

Lua, 125 bytes

Cuando el objeto se encuentra funcional, puedes hacer algunas cosas bonitas, ¡incluso en lua! No creo que pueda jugar golf, ya es un desastre, y ya estoy feliz de superar la mayoría de las respuestas de 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)

Sin golfos y explicaciones

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

En serio, 25 bytes

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

Pruébalo en línea!

Explicación:

,`'_' (Æ≈"ûù"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 : no competidor, 14 bytes

S'_RE`N-`dE!k?

Sí, agregué builtins para este desafío, pero esos no están especialmente dirigidos a este problema.

Esto funciona con la versión 0.1 del intérprete .

Ejecución de ejemplo

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

Explicación

     # Implícito: colocar la entrada en la pila (C)
S # Empujar un espacio a la pila (B)
'_ # Empuja un guión bajo a la pila (A)
R # En C reemplace B con A -> reemplace guiones bajos con espacios
     # la pila contiene ahora solo la cadena reemplazada (C)
E # Empuje una cadena vacía (B)
`# Iniciar un comando literal,
     # la pila para esto se inicializa con un solo carácter (B) más tarde
N # Empuje los dígitos 0-9 como cadena a la pila (A)
- # Elimina todos los personajes de B que están en A
`# Fin del comando literal (A)
d # dividir C en B, ordenar las partes descendiendo con la tecla A y volver a unir en B.
     # La función de tecla A transforma cada carácter de la cadena en una cadena vacía si es un dígito.
     # Dado que el carácter resultante no contiene un dígito, su valor clave es su longitud.
     # Esto asigna la clave 0 a dígitos y la clave 1 a no dígitos. Ordenar esto en descendente
     # order mueve los dígitos hacia la derecha y deja los no dígitos en el orden en que estaban antes.
E # Empuje una cadena vacía
! k # Presione el comando k (= swapcase)
? # Aplicar ^ a cada personaje al azar
     # Implícito: contenido de la pila de salida

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 sin golf:

$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)

Probablemente haya mucho margen de mejora aquí que resolveré más adelante.

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}

Se srand()necesita para darnos números aleatorios diferentes cada vez que se ejecuta.
Para que esto funcione correctamente con entrada de varias líneas, tendríamos que poner algo como A=N=""antes del forbucle.

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 puede ver, básicamente estoy usando la choicefunción del módulo aleatorio para elegir una función aleatoria (.upper () o .lower ()) para cada letra en la versión ordenada de la cadena dada, en la que todos los dígitos van al fin. Además, cada espacio se reemplaza con un guión bajo en la cadena ordenada.

PHP 164 caracteres / bytes

Esto es mejor que el otro golf PHP , porque:

• Toma entradas
• Es mas corto

Guión

<?$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;

Ejemplo

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 loco aquí:

• huellas dactilares _ cuando se encuentra 
• toma el mod 32 de letras, luego agrega aleatoriamente 8 * 8 o 12 * 8 antes de imprimirlas
• apila el número e imprímelos una vez que se alcanza el final de la entrada

¡Puedes probarlo aquí !

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)