您的挑战是密码字符串！您问什么是密码？

以字符串作为输入。该字符串将仅包含大写字母，小写字母，数字和空格。

您必须用下划线替换所有空格，并按从左到右的顺序将所有数字移动到字符串的末尾。然后，对于字符串中的每个字母，将其随机更改为大写或小写。

示例（字符大小写每次都不同）：

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

以字节为单位的最短代码胜出！

谁在Information Security SE上问这是否是一个好的哈希算法，那会取胜！-不用担心SE霸主，我只是在开玩笑。

Pyth，15个字节

s}D`MTrRO2Xzd\_

示范

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.

迷宫，76字节

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

与@MartinBüttner的另一项合作，以及在迷宫频谱更疯狂的一面–我们第一次将所有四个功能整合^>v<到一个程序中。在线尝试！

说明

循环运行的通用算法如下：

 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

为了使说明紧凑，这里大致是程序的每个部分与上面的伪代码对应的方式：

这是有趣的部分。

在迷宫中获得随机性

在迷宫中只有一种获得随机性的方法，那就是IP尝试前进时，但是1）既没有前进的路径也没有前进的路径，并且2）左右都有可用的路径。在这种情况下，IP会在左右路由之间随机选择。

这只能通过使用^>v<运算符来实现，该运算符会将n行/列弹出并移动n1。例如，该程序（在线尝试！）

" 1
""v!@
  2
   !@

随机输出1或2，因为将v偏移量为0的列（即IP所在的列）移动了1，产生了

"
""1!@
  v
  2!@

IP面向右并尝试前进（栈顶为零），但不能这样做。它也不能向后移动，因此可以在左右之间随机选择。

高尔夫技巧

• 程序从读取顺序中的第一个字符开始，您实际上会注意到它是第6步。但是，从空的迷宫堆栈弹出会产生0，因此发生步骤10和14，将零移位到辅助堆栈，这是有效的一个没有人。

• 每次迭代后，主堆栈实际上都是空的，这使我们可以通过在底部的隐式零上使用>和来进行代码布局<。在>包装的底部行，以便围绕从右下角的IP移动到左下角，并且<转移该行回来。IP然后愉快地在左列上移以继续循环。

• 位数迷宫流行n和推动10*n + <digit>。此外，字符在输出之前以256为模。将这两个放在一起，我们就可以通过`33对32（空格）进行运算来输出95（下划线），这是因为-3233 % 256 = 95。即使有其他方法可以将32转换为95（;95最简单），在此处使用负数也可以使我们向左转一点代码。

05AB1E，22 21 20字节

码：

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

使用CP-1252编码。

在线尝试！

CJam，25个字节

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

在线尝试！

说明

我的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个字节

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

在这里测试。

说明

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个字节

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

对其他 两个 Python答案的改进是因为：

• [...,'_'][c<'!']用于代替s.replace(' ','_')，和
• choice(c+c.swapcase()) 用于代替 choice([c.upper(),c.lower()])

的JavaScript（ES6），114个 101字节

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

47个字节只是为了随机化字符的大小写...

编辑：感谢@ edc65，节省了大量的13个字节。

MATL，27字节

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

在线尝试！

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个字符

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

感谢xnor削减了6个字节。

Perl 6，77 75 61字节

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

S///就像s///它没有$_在原地修改一样

Pyth，17个字节

smrdO2o}N`UT:zd\_

在这里尝试！

说明

smrdO2o} N`UT：zd \ _＃z =输入

            ：zd \ _＃用下划线替换空格
      o＃使用键功能对^进行排序（N）
       } N`UT＃N在“ 0123456789”中为数字赋予1，因此它们会在右侧排序
 m＃映射^的每个字符d
  rdO2＃将d个随机数转换为大写或小写
s＃将列表连接回一个字符串

Mathematica，86个字节

感谢Sp3000节省了1个字节。

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

啊，字符串处理Mathematica ...不好玩。这是一个未命名的函数，它接受并返回一个字符串。

由于所有语法糖，阅读顺序有点有趣：

Characters@#

将字符串拆分为字符，否则我们根本无法执行任何操作。

...~SortBy~{DigitQ}

将数字排序到末尾。通过将测试功能包装在列表中，我们使排序稳定。

...&/@...

将左侧功能映射到列表中的每个字符。

RandomChoice[{ToLowerCase,Capitalize}]

为当前角色选择一个随机的大小写转换函数。

...@#...

将其应用于当前字符。

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

用下划线替换空格。

...<>""

最后，将所有字符重新组合成一个字符串。

PowerShell，113字节

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

PowerShell代表可怕的高尔夫语言。拆分为char数组，并用下划线替换空格。把握每个角色和过程。将数字收集到变量$ d中以供以后输出。通过使用'char'.ToLower()或调用表达式，可以将每个其他字符随机转换为大写或小写'char'.ToUpper()。如果收集到任何数字，请将其附加在末尾。

朱莉娅88 87 78字节

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

这是一个匿名函数，它接受一个字符串并返回一个字符串。要调用它，请将其分配给变量。

首先，我们将输入字符串分成其字符数组，然后根据每个字符是否为数字对数组进行排序。这样可以保持文本和数字的顺序，但将数字推到末尾。然后，对于数组中的每个字符，我们检查它是否为空格。如果是这样，请用下划线替换，否则随机选择ucfirst或lcfirst应用于字符之一，从而分别将其转换为大写或小写。将数组连接成字符串，我们就完成了！

在这里尝试

Sp3000节省了9个字节！

Perl，51个48字节

包括+2 -lp

使用STDIN上的输入运行：

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

passwordify.pl：

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

因子，154字节

或222带导入 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 ;

我在打高尔夫方面不太好，而且我不确定在这里是否采取了最佳方法，但以为我会尝试一下

Ruby，84个字节

匿名函数。c.downcase由于某些原因，之前删除空格会导致语法错误，但我不确定为什么。

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

Lua，125字节

当对象满足功能时，即使在lua中，您也可以做一些漂亮的事情！我认为我不能打高尔夫球，这已经是一个很大的混乱，我已经很高兴击败大多数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)

脱节和解释

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

严重的是25个字节

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

在线尝试！

说明：

,`'_' (Æ≈"ûù"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-非竞争性14字节

S'_RE`N-`dE!k?

是的，我为这个挑战添加了内置函数，但是这些并不是专门针对此问题的。

这适用于解释器的0.1版。

运行示例

> python IPOS.py S'_RE`N-`dE！k？-i“ pa55 w0rd”
Pa_WrD550

说明

     ＃隐式：将输入放置在堆栈上（C）
S＃将一个空格推入堆栈（B）
'_＃将下划线插入堆栈（A）
R＃在C中用A替换B->用空格替换下划线
     ＃堆栈现在仅包含替换的字符串（C）
E＃推入一个空字符串（B）
`＃启动命令文字，
     ＃稍后使用单个字符（B）初始化此堆栈
N＃将数字0-9作为字符串推入堆栈（A）
-＃从A中删除B中的每个字符
`＃结束命​​令文字（A）
d＃在B上分割C，用键A排序降序的部分，然后在B上重新加入。
     ＃按键函数A将字符串的每个字符转换为空字符串（如果是数字）。
     ＃由于生成的char不包含数字，因此它的关键值是它的长度。
     ＃将键0映射到数字，将键1映射到非数字。按降序排序
     ＃order将数字向右移动，并使非数字保持以前的顺序。
E＃推送一个空字符串
！k＃推送命令k（= swapcase）
？＃随机将^应用于每个字符
     ＃隐式：输出堆栈内容

PHP，368字节

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

非高尔夫代码：

$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字节

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)

这里可能还有很多改进的余地，我稍后会解决。

AWK，128字节

{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}

将srand()需要每次运行时给大家带来不同的随机数。
为了使它与多行输入一起正常工作，我们需要A=N=""在for循环之前添加类似内容。

Python 3.5-118字节：

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

如您所见，我基本上是使用random模块的choice函数为给定字符串的排序版本中的每个字母选择一个随机函数（.upper（）或.lower（）），其中所有数字都转到结束。同样，每个空格都用排序后的字符串中的下划线替换。

PHP，164158个字符/字节

这比其他PHP golf更好，因为：

• 需要输入
• 更短

脚本

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

例

php password.php 'thats some 1337 shit'

ThATs_Some__sHiT1337

> <>，73个字节

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

这里没什么疯狂的，它：

• _遇到时打印 
• 接受字母的mod 32，然后在打印之前随机添加8 * 8或12 * 8
• 堆叠数字并在输入结束时打印它们

您可以在这里尝试！

Python 3，151个字节

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)