给定数字和字符串生成密码

您的任务很简单。给定一个字符串s和一个数字0 <= n <= 9作为输入，在字符串n时间的每个字符之间插入一个可伪随机打印的ASCII字符。这样，每个字符之间都s存在n随机字符。应修剪空间。

输入：

• s密码中要加密的字符串短语
• n范围内的整数0 <= n <= 9

例：

输入：

The treasure is here
2

输出：

Ť！0 ħ 32 ë F4 吨 0I ř LK Ë HM 一个 7Y 小号＃0 ü * - [R * H ë！2 我 H ^ 小号 B，ħ！@ ë 0）- [R $ H ë

这是代码高尔夫球，所以最短的代码获胜！祝好运并玩得开心点！

C＃，141131字节

与@Geobit的 Java答案非常相似，但当前时间更长：(

(I,n)=>{var R=new System.Random();var o="";int i,r;foreach(var c in I)if(c>32)for(i=r=0,o+=c;i++<n;){r=R.Next(33,127);o+=(char)r;}return o;};

完整的lambda内容：

Func<string, int, string> a = (I,n) =>
{
    var R=new System.Random();
    var o="";
    int i;
    foreach(var c in I)
        if(c>32)
            for(i=0,o+=c;i++<n;o+=(char)R.Next(33,127));
    return o;
};

05AB1E，11个字节

ð-vy²FžQ.RJ

在线尝试！

说明

ð-           # remove spaces from input string
  v          # for each char in the string
   y         # push the char
    ²F       # input-2 number of times do:
      žQ.R   # push a random ascii character
          J  # join to string

Java 7中，132个 124字节

String f(int n,char[]a){String o="";int i;for(char b:a)if(b>32)for(i=0,o+=b;i++<n;o+=(char)(33+Math.random()*94));return o;}

没什么好想的，只是您期望的双循环。外循环字符串，内循环填充随机数：

String f(int n,char[]a){
    String o="";
    int i;
    for(char b:a)
        if(b>32)
            for(i=0,
                o+=b;
                    i++<n;
                        o+=(char)(33+Math.random()*94));
    return o;
}

Pyke，12 11 9个字节

d-FQV~KHs

在这里尝试！

d-        -  remove spaces from input
  F       - for i in ^:
   QV     -  repeat (number) times:
     ~KH  -    random_from(printable)
        s -   sum(^)

根据OP，尾随的随机字符就可以了。

八度，43字节

@(s,n)[s(s>32);33+94*rand(n,nnz(s>32))](:)'

这需要一个字符串s和一个整数n作为输入。Octave中的字符串只是一个字符数组。s>32是具有1任何非空格字符的逻辑映射。该代码添加了一个n行和列数与之相同的矩阵s(s>32)，其中包含介于33和126之间的浮点数。将其隐式舍入为整数，并在与字符串连接时转换为ASCII字符s。(:)'将其拉直为水平的字符数组。

在这里测试！

Python 2中，123 122 118 114 98字节

伙计，我希望random不是那么贵（而且我们不必过滤空格）。现在，通过在末尾使用密码字符，我们可以节省很多钱：)无论如何，在这里：

from random import*
f=lambda s,n:s and(' '<s[0])*eval('s[0]'+'+chr(randint(32,126))'*n)+f(s[1:],n)

JavaScript（Firefox 30 +），96个字节

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32]))

纯ES6长两个字节：

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[...Array(n)].map(_=>Math.random()*95+32)))

这是一个非常酷的方法，可悲的是，它长了26个字节：

(s,n)=>String.raw({raw:s.split` `.join``},...[for(_ of s)String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32])])

R，97个字节

带有输入x（字符串）和的未命名函数n。

function(x,n,l=nchar(x))for(i in 1:l)cat(substr(x,i,i),if(i<l)intToUtf8(sample(32:126,n)),sep="")

在R小提琴上尝试

CJam，21 18字节

lS-(ol~f{{95mrSc+\}*}

在线尝试！

打印n随机的尾随字符。

说明

lS-        e# Read line and remove spaces.
l~         e# Read and evaluate another line.
f{         e# For each character (passing in N)...
  {        e#   Do this N times...
    95mr   e#     Push random integer in [0, 95).
    Sc+    e#     Add to space character, giving a random printable ASCII character.
  }*
}
           e# All characters remaining on the stack are printed implicitly
           e# at the end of the program.

Bash，124个字节

纯bash + coreutils，无控制流结构，无子语言，无“评估”

打高尔夫球

E() { N=${1// /};paste <(fold -1<<<$N) <(tr -cd "\\40-\\176"<\/dev\/urandom|head -c$(($2*${#N}-$2))|fold -$2)|tr -d '\t\n';}

测试

>E "The treasure is here" 2
TkZhf(e&Rt@FrS,edha+-sJTuh.rX@eVKi+3s<7hftey8r*/e

Q / KDB +，39 36 34字节

raze{""sv(raze x;`char$40+n?87)}prior s
(,/)({""sv((,/)x;`char$40+n?87)}':)s

(,/)({""sv((,/)x;10h$40+n?87)}':)s

使用的变量：

s:"The treasure is here"
n:2

这使用 前副词，到它的每一个项目的权利和它的前身之间留下了一种应用功能。（本质上，将功能应用于右侧每个字符之间的左侧。）

生成40到126之间的n个随机数，然后将其转换为等效字符：（q似乎只包含这些字符）

`char$40+n?87

//Possible characters.
()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~

输出示例：

TVghrveVp Rpti+r0sea3a9nsIjuRXrAReJ; +di=ys`{ ikhKTe4trTZesz

编辑：
使用k表示法将q的raze转换为（，/），节省了3个字节，类似地在`之前进行了更改：感谢@slackwear进行更新，将2个字节剃了:)

Java 8，114字节

打高尔夫球

(n,s)->s.chars().forEach((c)->{if(c>32)for(int i=0;i<=n;)System.out.print((char)(++i==1?c:33+Math.random()*94));})

接受整数和字符串的Lambda。受Java 7答案的启发，使用某些Java 8 Stream语法进行了双循环（String.chars）进行以节省一些字节。

输入值

3, "Hello world!"

输出量

HfKIedb3l<-Ul%}vod"Bw\"|oa`%rH-}l/-{dMS;!B#X

Scala，95 94字节

def c(s:String,i:Int)=s.filter(_>32).mkString(scala.util.Random.alphanumeric.take(i).mkString)

除了在String上使用mkString外，没有什么花哨的地方。它将字符串视为字符列表，并允许我在它们之间插入分隔符。我的分隔符是适当数量的随机生成的字母数字字符。

> <>（FISH），107个 106 103字节

<v}:{r&" "
1xv+
2<v+
v}<
<~v!?=&:&:
6.>ol2-?!;a
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o-+
^3<v ~}}r]~<
.40<

在线尝试！

它不是超级随机的，但它是随机的。只需将字符串和整数放在堆栈上即可（例如：“ Hello world！”，5）。

Input: "Hello world!", 5
Output: H^\^]^eceeedldcdeclgfffhowhhfggojkkkkrdccedl]]\]\d

完整说明

在我更新说明之前，这是该代码的稍旧版本。基本上是相同的，也许更容易阅读：

< v}:{r&" "
+1xv
+2<v
   }
:&:<~ v!?=&
?!;a6.>ol2-
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

我们假设字符串参数为s，整数参数为i。

< v}:{r&" "

该<通知的鱼立刻向左移动，其环绕于" "，增加characted到堆栈空间。然后鱼越过&，这增加了收银机的空间。r反转堆栈并将{:}堆栈向左移动（放在i堆栈的末尾），将值复制到堆栈的末尾，然后将其向右移动。v告诉鱼开始向下移动。

+1xv
+2<v
   }

x告诉鱼沿随机方向移动，最终导致鱼向右走并继续向下，或者越过1+或2+事先。它们分别在堆栈末尾的数字上加1或2。如果鱼向上运动，它将v再次撞击并向下运动。}向右移动堆栈，然后将其i放在堆栈上的位置1处，并将此新变量放在位置0处（我们将其称为m）。

:&:<~ v!?=&

这部分是一个函数，我们称其为whitespaceTrimmer。它从那里开始<。它只是剥离堆栈末尾的空间（因此是字符串的开头），直到遇到非空格字符为止。

因此，鱼立即游入水中<，必须向左移动。然后碰到:&:&，将值复制到堆栈的末尾，将寄存器中的空间放到堆栈的末尾，复制它，然后将其放回寄存器。

然后，鱼击中=?!v ~或更具体地将击中，=这会将最后两个值（我们刚刚创建的两个）从堆栈中弹出，进行比较，如果相等，则将1放在堆栈的末尾，将0放在堆栈上如果它们不同，则返回堆栈的末尾。将?新值弹出堆栈的末尾，如果为0，则不执行下一条指令（在本例中为）!，而是执行v，该指令命令鱼向下移动（退出该函数）。

但是，如果它是1，则说明它已经找到了一个空间，因此执行!一条是蹦床的操作，这将导致鱼跳过下一条指令，即a v，因此鱼​​继续操作。在鱼的前面，它看到~哪个告诉它将最后一个值从堆栈中弹出（确认为空格），然后鱼继续运行，并再次运行该函数。

?!;a6.>ol2-

立即通过指示鱼游动>，然后输出堆栈上的最后一个字符o（第一次运行时，是的第一个字符s）。它从中获取堆栈的长度，在堆栈的末尾l放置a 2，然后-从中减去2 l。它击中了?!;它，记住是什么?，导致鱼!在堆垛为空的情况下跳过鱼，落在鱼上;，从而结束程序。

接下来，如果堆栈上仍然有字符，我们执行!，使鱼在上反弹，;然后执行a6.（存储a（AKA 10））并6在堆栈的末尾执行，即x, y坐标）将.其弹出到末尾。堆起来，然后将鱼传送到10, 6，并在该位置的右边执行指令（因为鱼在正确游动）。

这比您意识到y位置6是该位置下方的线时听起来的复杂程度要小。x位置10是v，在其右侧是，这是空操作。这导致鱼继续正确游动，并实际上在行的开头开始执行...

:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

因此，这是在字符之间添加随机文本的功能。有点大嘴巴，但这只是因为我试图使其更加随机。叫这个 genRandomChars。

该:{{:}l1-[rv实际上是功能设置，少那么实际功能本身的一部分。鱼先游过:{{，将值复制到堆栈的末尾，然后将其向左移动两次。如果你还记得i是堆栈中的位置1，那么您会知道i现在位于堆栈的末尾。

然后，鱼在上面的:}副本上游泳i，并将堆栈向右移动，i同时放在堆栈的开始和结尾。l1-[让鱼将长度放在堆栈的末端，从堆栈的末端减去1，然后[创建一个新堆栈，将值l-1（堆栈长度减去1）移动到新堆栈上（因此只留i在旧堆栈上）。然后鱼就碰到了rv，这再次使堆栈反转（我认为创建新堆栈会由于某种原因将其反转），并命令鱼再次向下游动，从而在<下面真正启动该功能。

所以目前堆栈的末尾有m和我们的临时的i，我们称之为ti。鱼立即游过1-}，从中减去1 ti并将其移动到堆栈的开头。然后:}，它简单地m将其复制并移动到堆栈的开头（放在ti堆栈位置1）。

这是我们碰到这个小东西的时候：

v2<
<1x|!
^3<

这实际上很简单。将!导致鱼跳过|并执行x。记住是什么x，我们记得这会使鱼向任何四个方向移动。|只是一面镜子，使鱼游回x。因此，基本上，鱼将1、2或3放在堆栈的末端，然后继续向左移动，环绕。

然后执行鱼操作*+o，这会导致堆栈上的最后两个值弹出，相乘，然后推回结果，然后添加相同的东西，然后从堆栈上弹出最终值，并用输出o。现在我们的堆栈又相对正常了，只包含[ m，ti，s。

:}}:使堆栈末尾的值（基本上是s位置0）被复制，然后将堆栈右移两次（ti再次放置在前面），然后ti将其复制。?!v现在应该已经很容易理解了。基本上，如果ti为0，则使用退出函数v，否则执行!并跳过v（执行另一个循环）。

如果ti为0，并且我们完成了输出稍微随机的字符的操作，那么我们将执行以下操作v：

   v ~}}r]~<
.43<

这里没什么好看的。我们ti通过将其从堆栈中删除~。然后]是新的，它将所有值从堆栈中弹出，并将其放在旧堆栈中！因为反转的问题，我们有扭转r，然后用移堆右侧的两倍}}~，shufting堆栈的权利，给我们[ m，i，s]，则~是去除重复多余的s[0]，从早期的功能我们会如果需要它我们正在做一个循环（但不是，我们要退出）。v告诉鱼儿向下游泳并进入>34.（倒转以显示执行顺序），这告诉鱼儿简单地向左游泳并进入3, 4（因为这.是一个跳跃！）。3, 4实际上只是在开始的右边whitespaceTrimmer，这很完美，因为我们要向左行驶。

遵循所有这些逻辑，我们可以跟踪鱼，直到堆栈最终为空并在whitespaceTrimmer执行后立即退出程序。

Perl 5，81个字节

($_,$n)=<>;chomp;y/ //d;$\=chop;print map{$_,map{chr 33+int rand 94}1..$n}split//

我希望以下内容可以帮助您了解单线工作：

($_, $n) = <STDIN>;  # Reads in the string into $_,
                     # and the number into $n, from standard input.
                     # (<STDIN> works slightly different from <>.)
chomp($_);           # Removes the newline from the string.
$_ =~ tr/ //d;       # `Tr/`ansliterates ASCII space characters
                     # into nothing, effectively `/d`eleting them.
$\ = chop($_);       # Chop()s off the last character out of $_ and
                     # appends it to the output when print()ing.
                     # (Perl always prints $\ after you call print().)
print( map {         # Each element of [List 1] will be mapped to:
    $_,              #   -- Itself, and
                     # (When mapping, each element is available as $_.)
    map {            # (`map` resembles `foreach` but returns a list.)
        chr(         #   -- A random ASCII character, in the range
          33 + int(rand(94)) ) # from 33 (!, hex 21) to 126 (~, hex 7E)
    } 1..$n          # ...$n times! (Over the range 1 to $n, actually.)
} split(//, $_) );   # [List 1] is $_, split() into characters.

Clojure中，126个 123 118 122 117字节

(defn c[m n](apply str(remove #(=\space %)(mapcat #(apply str %(for [_(range n)](char(rand-nth(range 32 127)))))m))))

映射消息，在其中插入随机字符，然后合并结果。

这些说明建议应从结果字符串中删除所有空格。如果只应该删除原始消息中的空格，则可以更改它。

取消高尔夫：

(defn cipher [message n]
  (apply str
    (remove #(= \space %)
        (mapcat #(apply str %
                     (for [_ (range n)]
                       (char (rand-nth (range 32 127)))))
                message))))

Python 3，127字节

import random
a,b=input(),input()
print(''.join([x+''.join([chr(random.randint(33,126))for c in range(int(b))]) for x in a]))

可能比必要的时间更长，但这是迄今为止我的高尔夫。

PHP，96字节

将String作为参数1，将Number作为参数2

for(;($s=str_replace(' ','',$argv[1]))[$j]>'';)echo$i++%($argv[2]+1)?chr(rand(33,127)):$s[$j++];

在线尝试

Python 3，133字节

from random import *
c=int(input())
print(''.join([i+''.join([chr(randint(33,126))for i in range(c)])for i in input().strip(' ')])[:-c])

Node.js，88个字节

(s,n)=>s.replace(/./g,c=>c!=" "?c+crypto.randomBytes(n).toString`base64`.substr(0,n):"")

输出示例：

f("The treasure is here", 2)
// THphdwekAtMArbSeU1aDTsZWuqnr2yek1iyUsKshqXewvrVCeTi

f("The treasure is here", 2)
// TYshlcep6t4Iru7e29aQ1sl/uvQrlzeSJihysDhhOLe1urpte1m

在线尝试！

C，102100字节

-2个字节用于跳过continue。

i;f(char*s,int n){do{while(*s==32)++s;putchar(*s);i=n;while(i--)putchar(32+rand()%95);}while(*s++);}

取消高尔夫：

i;
f(char*s,int n){
 do{
  while(*s==32)++s;
  putchar(*s);
  i=n;
  while(i--)
    putchar(32+rand()%95);
 }while(*s++);
}

用法：

main(){
  char a[]="A   A A";
  f(a,3);
}